Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] string ausrechnen mit regulären ausdrücken und ohne eval()

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • #16
    Hi,
    nachdem Frank hier schon Code gepostet hat und Toben damit vermutlich schon freudestrahlend zu seinem Chef gerannt ist, hier mein Versuch:
    PHP-Code:
    /*
     * math_parse berechnet mathematische Ausdrücke ohne die Nutzung von eval 
     * operatoren: + - * / ^ ( )
     * funktionen: sqrt, sin, cos
     */
    function math_parse($strMath
    {
      
    $fktlist = array('sqrt','sin','cos');
      
      
    $bparse = function($math) {
        
    $ops = array('^','/','*','+','-');
        foreach(
    $ops as $op) {
          
    $regEx '~(^\-\d+\.?\d*|\d+\.?\d*)'.preg_quote($op).'([\-+]?\d+\.?\d*)~';
          while(
    preg_match($regEx,$math,$match)) {
            list(
    $all,$v1,$v2) = $match;
            if(
    $op == '^'$r pow($v1,$v2);
            if(
    $op == '/'$r $v1/$v2;
            if(
    $op == '*'$r $v1*$v2;
            if(
    $op == '-'$r $v1-$v2;
            if(
    $op == '+'$r $v1+$v2;
            
    $math str_replace(
              array(
    $all'+-','-+','--','++'),
              array( (string)
    $r ,'-','-','+','+'),
              
    $math
            
    );
          }
        }
        return 
    is_numeric($math) ? (float)$math false;
      };
      
      
    $strMath str_replace(
        array(
    ' ',','),
        array(
    '','.'),
        
    $strMath
      
    );
      
      
    $regEx '~('.implode('|',$fktlist).')?\(([^()]+)\)~';
      while( 
    preg_match($regEx,$strMath,$match)) {
        
    $expr $bparse($match[2]);
        if(
    $match[1] !== ''$expr $match[1]($expr);
        
    $strMath str_replace($match[0],$expr,$strMath);
        
    debug::write($match);
      }
      return 
    $bparse($strMath) ;

    Das Beispiel zeigt, daß mit regulären Ausdrücken einiges zu machen ist, etwas Erfahrung ist jedoch notwendig. Der Code ist noch recht kurz, aber auch dem geschuldet, daß gegen den allgemeinen Coding-Standard verstoßen wird. Ich kann mich einfach nicht daran gewöhnen, daß ich dies
    PHP-Code:
    if($op == '/'$r $v1/$v2
    so schreiben soll
    PHP-Code:
    if($op == '/') {
        
    $r $v1/$v2;

    und Würmer wie
    PHP-Code:
    while(preg_match('~(^\-\d+\.?\d*|\d+\.?\d*)'.preg_quote($op).'([\-+]?\d+\.?\d*)~',$math,$match)) { 
    formal in Ordnung gehen. Aber dies nur nebenbei.

    Die obige Funktion wurde kurz getestet, schafft auch Klippen wie '-3*-5'.
    Aber keine Rede von Totgetestet.

    Edit: Was spricht gegen eval, wenn ich den String entsprechend validiere?


    LG jspit

    Kommentar


    • #17
      vermutlich, dass die Validierung exakt so lang ist , wie der komplette Code zur Berechnung wie bei dir

      außerdem SOLL er höchstwahrscheinlich zur Erkenntnis kommen, dass er eben einen Parser braucht - der eval-Aufruf ist nun doch arg zu einfach , wenn man mal die nötige Validierung unter den Tisch fallen lässt
      PHP-Code:
      eval("echo "."5+7*32-32*-3"."<br/>".";"); 
      [Quote=nikosch]
      So glatt kann doch wirklich keiner sein.[/quote] :roll:

      Kommentar


      • #18
        Validierung mathematische Ausdrücke für eval

        Zitat von beliar284 Beitrag anzeigen
        vermutlich, dass die Validierung exakt so lang ist , wie der komplette Code zur Berechnung wie bei dir
        Nö, weit entfernt von der Länge des obigen Codes.
        Da per eval so fast alles machbar ist was auch PHP beherrscht, sollte bei einem Einsatz die Validierung mit mit größter Sorgfalt erfolgen.
        Für die Funktion math_eval wird in einer Whitelist vermerkt, welche mathematischen Funktionen zugelassen werden.
        Bei der Prüfung sollte man nicht den Ergeiz besitzen, alles mit einem regulären Ausdruck zu erledigen.

        PHP-Code:
        function math_eval($strMath,$whitelist null){
          
        $check = empty($whitelist
              ? 
        $strMath 
              
        preg_replace('~(?<=\W|^)('.implode('|',$whitelist).')(?= *\()~','',$strMath)
          ;
          if(
        preg_match('~^[\d\.\-+*/,() ]+$~',$check)) {
              
        $v = @eval('$result ='.$strMath.';');
              if(
        $v === null) return $result;
          }
          return 
        false;

        So werden hier im ersten Schritt alle zugelassenen Funktionen aus dem Ausdruck entfernt.
        Im zweiten Schritt wird geprüft, ob nur noch Ziffern und mathematische Zeichen vorhanden sind.
        Dann erst wird der Orginalstring eval zur Ausführung übergeben. Dieser String ist ungefährlich, kann aber immer noch zu Fehlern führen.
        Dies wird durch Auswertung des Rückgabewertes von @eval abgefangen, so daß keine Fehler geworfen werden.
        Ausnahmen sind eine fehlerhafte Whitelist oder Fehler die von den aufgerufenen Funktionen verursacht werden.

        Beispiel für einen Test:
        PHP-Code:
        $fktWhiteList = array('sqrt','sin','cos','pow','pi');
        $tests = array(
            
        '30+8*27-15/3',
            
        'evil()',
            
        'sqrt( sin(0.5)*sin(0.5) + cos(0.5)*cos(0.5) )',
            
        'pow(3,2)',
        );
        foreach(
        $tests as $mathStr) {
            
        $result[$mathStr] = math_eval($mathStr$fktWhiteList);
        }
        debug::write($result); 
        Ausgabe:
        Code:
        [29.08.2013 13:55:26,281][+143 μs](508k/514k) Debug::write ..
        array (
          '30+8*27-15/3' => 241,
          'evil()' => false,
          'sqrt( sin(0.5)*sin(0.5) + cos(0.5)*cos(0.5) )' => 1,
          'pow(3,2)' => 9,
        )
        Vorteil dieser Variante liegt neben dem kurzen Code in der Geschwindigkeit der Ausführung und hohen Flexibilität u.a. durch die Möglichkeit der Benutzung eigener Funktionen.

        LG jspit

        Kommentar


        • #19
          zufrieden bin ich noch nicht, immerhin will ich daraus lernen... ich habs bis jetzt immernoch mit preg_split (wie frank es gemacht hat), es ist zwar noch Fehlerhaft, ist aber noch verständlich für mich.
          wurzeln, potenzen und klammern brauch ich überhaupt nicht, es geht wirklich nur um die PvS-rechnung.

          @jspit:
          deine Methode ist zwar umfangreich (was rechnungen angeht) aber im extremfall immernoch fehlerhaft aber trotzdem danke, dass ihr mir alle helft

          Kommentar


          • #20
            hab nochmal mit meinem Chef geredet: Bsp.: 1*(5+(3-2)*1)+5

            -Ich nehme den String, suche nach der letzten öffnenden Klammer und speichere ihren Stellenwert (6) in einer Valiable,
            -anschließend suche ich nach der ersten schließenden Klammer die einen Stellenwert von > 6 hat (10)
            -mit einer for-schleife suche ich alle zahlen und zeichen zwischen 6 und 10 heraus und speichere sie in eine variable die ich in die funktion calculate() einsetze (rechnet mit PvS-rechnung den string aus)
            -diesen ausgerechneten wert setze ich statt den Klammern ein, also muss an stelle 6 dieses erste Zwischenergebnis eingesetzt werden und alle danach kommenden stellen vorrücken(11-15 auf 7-11)
            -das ganze noch in eine while-schleife solange bis der dritte Stellenwert des strings nicht mehr vorhanden ist (der 3. weil "-3" drin stehen könnte)

            -die ersten 3 Schritte sollte ich hinbekommen, beim 4. weiß ich nich wie ich dieses "nachrutschen" realisieren soll, der 5. schritt ist ja nich viel... wär cool wenn ihr mir nochmal helfen könnt
            grüße Toben

            Kommentar


            • #21
              du denkst zu kompliziert

              wenn du deinen Klammern-Teil erledigt hast, weißt du:
              $rechnung="1*(5+(3-2)*1)+5";
              $startklammer : 5 (Zählung beginnt mit 0)
              $endKlammer : 10 (- eigentlich das Zeichen Hinter der Endklammer)
              String = "(3-2)"
              den rechnest du aus ="1"
              PHP-Code:
              $rechnung=str_replace("(3-2)","1",$rechnung); 
              fertig
              oder komplexer
              PHP-Code:
              $rechnung=str_replace(
                 
              substr($rechnung,$startklammer,$endklammer-$startklammer),
                 
              $ergebnisstring,
                 
              $rechnung
              ); 
              - da ist nix mit nachrutschen, weil str_replace eben den ganzen Ausdruck "(3-2)" durch "1" ersetzt hat
              [Quote=nikosch]
              So glatt kann doch wirklich keiner sein.[/quote] :roll:

              Kommentar


              • #22
                fast fertig

                PHP-Code:

                // um Buchstaben u.a. zu entfernen
                $var $_POST["text"];
                $regex ='/[^0-9\-\+\*\/\)\(]/';
                $var preg_replace($regex,'',$var);

                // macht aus string $var den array $splitvar
                preg_match_all('/(\d+)|([\(\)\-\*\/+])/',$var,$splitvar);
                // funktion zum PvS-rechnen ohne eval() und nur +-*/
                function calculate($data)
                {
                    
                preg_match_all('/(\d+)|([-\*\/+])/',$data,$splitdata);
                    
                print_r ($splitdata[0]);
                // solange, bis die Teilgleichung aufgelöst ist
                    
                while($splitdata[0][2]) //(bis das array keine dritte stelle hat)
                    
                {
                        
                $schleife true;
                        
                // setzt $count auf den letzten index von splitdata
                        
                end($splitdata[0]);
                        
                $count key($splitdata[0]);
                    
                // solange, bis alle * und / berechnet und ersetzt wurden
                        
                while($schleife == true)
                        {
                            if(
                $splitdata[0][$count] == "*")
                            {
                                
                $cal $splitdata[0][$count-1] * $splitdata[0][$count+1];
                                
                $data=str_replace(substr($data,$count-1,$count+1-($count-1)),$cal,$data);
                            }
                            if(
                $splitdata[0][$count] == "/")
                            {
                                
                $cal $splitdata[0][$count-1] / $splitdata[0][$count+1];
                                
                $data=str_replace(substr($data,$count-1,$count+1-($count-1)),$cal,$data);
                            }
                            if(
                $count <= "0")
                            {
                                
                $schleife false;
                            }
                            
                $count--;
                        }
                        
                // jetzt das gleiche nochmal eben nur mit + und - statt * und /
                        
                        
                $schleife true;
                        
                end($splitdata[0]);
                        
                $count key($splitdata[0]);
                    
                // solange, bis alle + und - berechnet und ersetzt wurden
                        
                while($schleife == true)
                        {
                            if(
                $splitdata[0][$count] == "+")
                            {
                                
                $cal $splitdata[0][$count-1] + $splitdata[0][$count+1];
                                
                $data=str_replace(substr($data,$count-1,$count+1-($count-1)),$cal,$data);
                            }
                            if(
                $splitdata[0][$count] == "-")
                            {
                                
                $cal $splitdata[0][$count-1] - $splitdata[0][$count+1];
                                
                $data=str_replace(substr($data,$count-1,$count+1-($count-1)),$cal,$data);
                            }
                            if(
                $count <= "0")
                            {
                                
                $schleife false;
                            }
                            
                $count--;
                        }
                    }
                // funktion gibt $data als ergebnis zurück
                return $data;
                }



                // hier die "main"
                // solange, bis die komplette Gleichung aufgelöst ist
                while($splitvar[0][2]) // (bis das array keine dritte stelle hat)
                {
                    
                end($splitvar[0]);
                    
                $counter key($splitvar[0]);
                    
                // die letzte ( suchen
                    
                while($splitvar[0][$counter] != '(')
                    {
                        
                $counter--;
                        
                $clipopen $counter;
                    }
                    echo 
                $splitvar[0][$counter]."<br>";
                    
                // die nächste ) suchen
                    
                while($splitvar[0][$counter] != ")")
                    {
                        
                $counter++;
                        
                $clipclose $counter;
                    }
                    echo 
                $splitvar[0][$counter]."<br>";
                    
                // den string dazwischen in $clip schreiben
                    
                $counter $clipopen 1;
                    
                $clip "";
                    while(
                $counter $clipclose)
                    {
                        
                $clip .= $splitvar[0][$counter];
                        
                $counter++;
                    }
                // Funktionsaufruf
                    
                $clip calculate($clip);
                // Teilergebnis in die gleichung einsetzen
                    
                $var=str_replace(substr($var,$clipopen,$clipclose-($clipopen-1)),$clip,$var);

                    
                preg_match_all('/(\d+)|([\(\)\-\*\/+])/',$var,$splitvar);


                }
                //Ausgabe
                echo $_POST["text"]." = ".$var

                Das ist mein code bis jetzt, danke an beliar hast sehr geholfen,
                das Einzige, das noch nicht funktioniert ist:

                bei der while-schleife:
                PHP-Code:
                // solange, bis die komplette Gleichung aufgelöst ist
                while($splitvar[0][2]) // (bis das array keine dritte stelle hat) 
                und der anderen in der function calculate(), bildet sich eine Endlosschleife, da an der dritten Stelle ([0][2]) noch etwas steht,
                habs mit null und "" probiert, klappt aber nicht.
                ansonnsten müsste alles richtig sein

                schaut nochmal drüber wenn ihr lust habt
                grüße

                Kommentar


                • #23
                  schau halt nach mit var_dump($splitvar); , WAS da noch ist - evtl fehlt dir nur ein trim()
                  [Quote=nikosch]
                  So glatt kann doch wirklich keiner sein.[/quote] :roll:

                  Kommentar


                  • #24
                    wurzeln, potenzen und klammern brauch ich überhaupt nicht
                    hab nochmal mit meinem Chef geredet: Bsp.: 1*(5+(3-2)*1)+5 …
                    [COLOR="#F5F5FF"]--[/COLOR]
                    [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                    „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                    [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                    [COLOR="#F5F5FF"]
                    --[/COLOR]

                    Kommentar


                    • #25
                      am Anfang stand die Aufgabe ohne Klammern - aber beim Nachfragen meinte dann SEIN Chef, dass Klammern ganz nützlich seien - und will die nun auch haben

                      Würde mich nicht wundern, wenn er Montag dann auch Wurzeln und Potenzen und Exponential-FUnktionen und Logarithmus drin haben will ... und WInkelfunktionen auch *fg*
                      [Quote=nikosch]
                      So glatt kann doch wirklich keiner sein.[/quote] :roll:

                      Kommentar


                      • #26
                        Zitat von beliar284 Beitrag anzeigen
                        am Anfang stand die Aufgabe ohne Klammern - aber beim Nachfragen meinte dann SEIN Chef, dass Klammern ganz nützlich seien - und will die nun auch haben
                        so isses

                        hab den eigentlichen schleifenfehler beseitigt, aber funktioniert immernoch nicht

                        Kommentar


                        • #27
                          Schubbbbbbs - Mal als alternativer Denkansatz:

                          PHP-Code:
                          <?php


                          function check ($sFormula $bEval false) {

                              
                          $sFormula trim ($sFormula);

                              if (
                          == preg_match ('#^\(*[-+]?\d[-+*/\d()\040\t\.]*$#' $sFormula)) {
                                return 
                          false;
                              }

                              if (
                          substr_count ($sFormula '(') != substr_count ($sFormula ')')) {
                                return 
                          false;
                              }

                              if (
                          $bEval) {
                                return 
                          false !== @ eval ($sFormula ';');
                              }
                              
                              return 
                          true;
                          }


                          function 
                          tokenize ($sFormula) {

                              
                          $aTokens token_get_all ('<?php ' $sFormula);
                              
                          array_shift ($aTokens);

                              
                          $aBraceStack = array ();

                              foreach (
                          $aTokens as $iKey => $mToken) {

                                if (
                          is_scalar ($mToken)) {

                                  if (
                          '(' == $mToken) {
                                    
                          $sType 'bracket:opening';
                                    
                          $aBraceStack[] = $iKey;
                                  }
                                  elseif (
                          ')' == $mToken) {
                                    
                          $sType 'bracket:closing';

                                    if (
                          null === $iOpener array_pop ($aBraceStack)) {
                                      throw new 
                          exception ('bracket order error');
                                    }

                                    
                          /*
                                    
                                    Hier möglich: leere Klammern aussortieren
                                    
                                    */

                                    
                          $aTokens[$iKey]               = array ();
                                    
                          $aTokens[$iKey]['type']       = $sType;
                                    
                          $aTokens[$iKey]['token']      = $mToken;
                                    
                          $aTokens[$iKey]['related']    = $iOpener;
                                    
                          $aTokens[$iOpener]['related'] = $iKey;
                                    continue;
                                  }
                                  elseif (
                          in_array ($mToken , array ('+' '-' '*' '/'))) {
                                    if (
                          == $iKey || 'operator' == $aTokens[$iKey 1]['type']) {
                                      
                          $sType  'sign';
                                      
                          /*
                                      
                                      Hier möglich: + Vorzeichen aussortieren
                                      
                                      */
                                    
                          }
                                    else {
                                      
                          $sType  'operator';
                                    }
                                  }
                                  else {
                                    throw new 
                          exception ('unknown token: ' $mToken);
                                  }
                                }
                                elseif (
                          T_DNUMBER == $mToken[0] || T_LNUMBER == $mToken[0]) {
                                  
                          $sType  'number';
                                  
                          $mToken $mToken[1];

                                  
                          /*
                                      
                                  Hier möglich: mit vorausgehndem Vorzeichen zusammenfassen
                                      
                                  */

                                
                          }
                                else {
                                  throw new 
                          exception ('unknown token: ' $mToken[1] . ' (' token_name ($mToken[0]) . ')');
                                }

                                
                          $aTokens[$iKey] = array (
                                                   
                          'type'    => $sType  ,
                                                   
                          'token'   => $mToken ,
                                                 );
                              }
                              
                              if (array () !== 
                          $aBraceStack) {
                                throw new 
                          exception ('bracket order error');
                              }

                              return 
                          $aTokens;
                          }


                          $sFormula '+1*(5+(3-22)*-1.5)+5';

                          ?><pre><?php

                          var_dump 
                          ($sFormula check ($sFormula 1));
                          print_r (tokenize ($sFormula));
                          [COLOR="#F5F5FF"]--[/COLOR]
                          [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                          „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                          [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                          [COLOR="#F5F5FF"]
                          --[/COLOR]

                          Kommentar


                          • #28
                            PHP-Code:
                            // um Buchstaben u.a. zu entfernen
                            $var $_POST["text"];
                            $regex ="/[^0-9\-\+\*\/\)\(]/";
                            $var preg_replace($regex,'',$var);

                            $var "(".$var.')';

                            // macht aus string $var den array $splitvar
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$var,$splitvar);

                            // funktion zum PvS-rechnen ohne eval() und nur + - * /
                            function calculate($data)
                            {
                            echo 
                            "<br>".$data." = ";
                                
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                            // solange, bis die Teilgleichung aufgelöst ist
                                
                            while($splitdata[0][2]) //(bis das array keine dritte stelle hat)
                                
                            {
                                    
                            $schleife true;
                                    
                            // setzt $count auf den letzten index von splitdata
                                    
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                    
                            $count 0;
                                
                            // solange, bis alle * und / berechnet und ersetzt wurden
                                    
                            while($schleife == true)
                                    {
                                        if(
                            $splitdata[0][$count] == "*")
                                        {
                                            
                            $cal $splitdata[0][$count-1] * $splitdata[0][$count+1];
                                            
                            $data=str_replace(substr($data,$count-1,$count+1-($count-2)),$cal,$data);
                                            
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                            
                            $count = -1;
                                        }
                                        if(
                            $splitdata[0][$count] == "/")
                                        {
                                            
                            $cal $splitdata[0][$count-1] / $splitdata[0][$count+1];
                                            
                            $data=str_replace(substr($data,$count-1,$count+1-($count-2)),$cal,$data);
                                            
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                            
                            $count = -1;
                                        }
                                        
                            end($splitdata[0]);
                                        
                            $countend key($splitdata[0]);
                                        if(
                            $count >= $countend)
                                        {
                                            
                            $schleife false;
                                        }
                                        
                            $count++;
                                    }
                                    
                            // jetzt das gleiche nochmal eben nur mit + und - statt * und /
                                    
                                    
                            $schleife true;
                                    
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                    
                            $count 0;
                                
                            // solange, bis alle + und - berechnet und ersetzt wurden
                                    
                            while($schleife == true)
                                    {
                                        if(
                            $splitdata[0][$count] == "+")
                                        {
                                            
                            $cal $splitdata[0][$count-1] + $splitdata[0][$count+1];
                                            
                            $data=str_replace(substr($data,$count-1,$count+1-($count-2)),$cal,$data);
                                            
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                            
                            $count = -1;
                                        }
                                        if(
                            $splitdata[0][$count] == "-")
                                        {
                                            
                            $cal $splitdata[0][$count-1] - $splitdata[0][$count+1];
                                            
                            $data=str_replace(substr($data,$count-1,$count+1-($count-2)),$cal,$data);
                                            
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                            
                            $count = -1;
                                        }
                                        
                            end($splitdata[0]);
                                        
                            $countend key($splitdata[0]);
                                        if(
                            $count >= $countend)
                                        {
                                            
                            $schleife false;
                                        }
                                        
                            $count++;
                                    }
                                
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$data,$splitdata);
                                }
                                echo 
                            $data."<br>";
                            // funktion gibt $data als ergebnis zurück
                            return $data;
                            }

                            // hier die "main"
                            // solange, bis die komplette Gleichung aufgelöst ist
                            while($splitvar[0][2]) // (bis das array keine dritte stelle hat)
                            {
                                
                            end($splitvar[0]);
                                
                            $counter key($splitvar[0]);
                                
                            // die letzte ( suchen
                                
                            while($splitvar[0][$counter] != '(')
                                {
                                    
                            $counter--;
                                    
                            $clipopen $counter;
                                }
                                
                            // die nächste ) suchen
                                
                            while($splitvar[0][$counter] != ")")
                                {
                                    
                            $counter++;
                                    
                            $clipclose $counter;
                                }
                                
                            // den string dazwischen in $clip schreiben
                                
                            $counter $clipopen 1;
                                
                            $clip "";
                                while(
                            $counter $clipclose)
                                {
                                    
                            $clip .= $splitvar[0][$counter];
                                    
                            $counter++;
                                }
                            // Funktionsaufruf
                                
                            $clip calculate($clip);
                            // Teilergebnis in die gleichung einsetzen
                                
                            $var=str_replace(substr($var,$clipopen,$clipclose-($clipopen-1)),$clip,$var);
                                echo 
                            "<br>".$var."<br>";
                            preg_match_all('/([\(\)\-\*\/+])|(-?\d+)/',$var,$splitvar);
                            }
                            //Ausgabe
                            echo "<br><br>Ergebnis: ".$_POST["text"]." = ".$var;


                            so weit bin ich jetzt, die vorgegebene Gleichung kann ich damit lösen,
                            allerdings tauchen Fehler auf, sobald eine negative Zahl entsteht ( wie z.B. "-1") :/

                            Kommentar


                            • #29
                              Da hilft nur: Fehler korrigieren.
                              [COLOR="#F5F5FF"]--[/COLOR]
                              [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                              „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                              [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                              [COLOR="#F5F5FF"]
                              --[/COLOR]

                              Kommentar


                              • #30
                                tja - weil dein Code Operator-Zeichen eben nur im Kontext "Rechenzeichen" kennt - nicht aber als "Vorzeichen" - die Erkennung musst du noch einbauen.
                                [Quote=nikosch]
                                So glatt kann doch wirklich keiner sein.[/quote] :roll:

                                Kommentar

                                Lädt...
                                X