schnellste Variante für String Reduktion auf 1..9,0 und "." ","

[moelski]

Moin !

Was ist eurer Meinung nach die schnellste Variante um einen String auf das Wesentliche für eine Float Zahl zu reduzieren? Also den String so beschneiden das nur 1,2,3,4,5,6,7,8,9,0 und der (vorgegebene) Dezimalseperator über bleiben.

Bsp: "Der Glas ist zu 86,993% voll" -> Ergebnis : 86,993

Spontan würde ich ja sagen mit einer For Schleife durch die einzelnen Zeichen durchgehen und nur pässige Zeichen in einem neuen String wieder zusammenbauen.

Gibs da evtl. eine bessere / schnellere Varinate zu?

[Namenloser]

Im Grunde so wie du gesagt hast, nur dass man den neuen String von vornherein auf die Länge des Ausgangstrings setzen und dann für jedes übernommene Zeichen einen Zähler hochzählen lassen sollte, um am Ende den String zurechtzustutzen, statt einfach mittels + Zeichen an den String anzufügen. Auf diese Weise spart man Reallocs und Kopiervorgänge im Arbeitsspeicher.

[himitsu]

Das ist schon das Schnellste, solange du nicht jedes Zeichen einzeln anhängst.

- gleichlangen String resservieren,
- alles passende rüberkopieren (zeichen mitzählen)
- Stringlänge korrekt setzen

oder
- gültige Zeichen zählen
- String passender Länge reservieren
- alle gültigen zeichen rüberkopieren

PS: was soll alle sgültig sein?

"heute haben 123 Leute 45,9 Liter Milch getrunken" = 12345,9

[blackfin]

Uhm uhm, wenn mehrere Zahlen vorkommen: RegEx?

[Neutral General]

Ich denke, wenn er wirklich nur einfach immer alle Zahlen aus nem String gefiltert haben will, dann gehts ohne RegEx wahrscheinlich schneller.

[moelski]

Moin !

Ich will das nicht auf die Spitze treiben. Im Grunde brauche ich das für einen CSV Import und ich gehe mal davon aus das die User nicht so einen "Mist" importieren wie
"heute haben 123 Leute 45,9 Liter Milch getrunken"

Nicht böse gemeint

Wenn doch dann haben sie irgendwie unsere Software nicht verstanden

Ich denke ich werde folgendes tun:
1) String von vorne durchgehen und den angegebenen Dez. Seperator suchen.
2) Von der Position zurück gehen und solnage lesen wie man Gültige Zahlen erwischt und das dem neuen String hinzufügen.
3) Den System dez. Seperator dem String hinzufügen.
4) Von der Position (1) nach rechts gehen um die Nachkommastellen zu bekommen.

Bleibt nur das Problem wenn kein Dez. Sep vorhanden ist.
In dem Fall würde ich die erste zusammenhängede Zahl von Links nehmen.

Klar, das kann dann zu Fehlern führen denn die richtige Zahl könnte auch rechts, in der Mitte oder sonstwo stehen. Aber im Grunde geht es hier nur darum einen String sauber in eine Zahl zu überführen. Und so ganze Sätze wird man bei einem CSV Import eher weniger haben

[blackfin]

Dann würde ich einfach char für char durchgehen und schauen, ob das zu prüfende Zeichen erlaubt ist. Dann solange die Chars kopieren, bis ein unerlaubtes Zeichen gefunden wurde und die kopierten in einem Puffer speichern. Das ganze so oft machen, bis Ende im (String)-Gelände

Edit: blöder roter Kasten!

[Neutral General]

Ich würde es an deiner Stelle so machen wie himitsu es vorgeschlagen hat und dann die Gültigkeit der Zahl mit TryStrToFloat/Int oder StrToFloat(Int)Def/ "prüfen".

[Namenloser]

Stichwort: State-Machine. (Regex ist nebenbei im Grunde auch nix anderes)

Delphi-Quellcode:

function GetNumber(const Source: string): string;
type
  TParserState = (psInvalid, psValid, psDigit, psDecimalPoint, psDigitDecimals);
var
  c: char;
  State: TParserState;
  Len: integer;
  procedure Accept(c: char);
  begin
    inc(Len);
    Result[Len] := c;
  end;
begin
  State := psInvalid;
  Setlength(Result, length(Source));
  Len := 0;
  for c in Source do
  begin
    case State of
      psValid:
      begin
        SetLength(Result, Len);
        break; // wir gehen mal von nur einer zahl pro string aus, könnte man aber auch anpassen
      end;
      psInvalid:
      begin
        Len := 0;
        if c in ['0'..'9'] then
        begin
          Accept(c);
          State := psDigit;
        end;
      end;
      psDigit:
      begin
        if c in ['0'..'9','.'] then
        begin
          Accept(c);
          if c = '.' then
            State := psDecimalPoint;
        end
        else
          State := psValid;
      end;
      psDecimalPoint:
      begin
        if c in ['0'..'9'] then
        begin
          Accept(c);
          State := psDigitDecimals;
        end
        else
          State := psInvalid;
      end;
      psDigitDecimals:
      begin
        if c in ['0'..'9'] then
          Accept(c)
        else
          State := psValid;
      end;
    end;
  end;
end;

Das ganze ist ungetestet, soll aber auch eher als Illustration dienen...

[Daniela.S]

Ich mach so etwas gerne über Pointer, weil es einfach am Schnellsten ist. Keine Ahnung ob das jetzt die schönste Art ist, aber ich hatte damit noch nie Probleme.
Erkennt aber natürlich nicht wenn zwei Zahlenblöcke angegeben werden. Lässt sich aber leicht insofern umschreiben, dass die Routine nach dem ersten Zahlenblock abbricht und nur diesen zurückgibt.


Zum Beispiel für Delphi7 (AnsiString):

Delphi-Quellcode:

function ReduceString( str: String ): String;
var
  i        : Integer;
  len    : Integer;
  p1     : PByte;
  p2     : PByte;
begin
  len := Length( str );
  p1 := @str[1];
  p2 := p1;
  while len > 0 do begin
    case p1^ of
      Ord('0')..Ord('9'),
      Ord(',') : begin
                   p2^ := p1^;
                   Inc( p2 );
                   end;
      end;
    Inc( p1 );
    Dec( len );
    end;
  SetLength( str, Integer(p2) - Integer(str) );
  Result := str;
end;

Delphi2010 (Unicode):

Delphi-Quellcode:

function ReduceString( str: String ): String;
var
  i      : Integer;
  len    : Integer;
  p1      : PWord;
  p2      : PWord;
begin
  len := Length( str );
  p1 := @str[1];
  p2 := p1;
  while len > 0 do begin
    case p1^ of
      Ord('0')..Ord('9'),
      Ord(',') : begin
                   p2^ := p1^;
                   Inc( p2 );
                   end;
      end;
    Inc( p1 );
    Dec( len );
    end;
  SetLength( str, (Integer(p2) - Integer(str)) div 2 );
  Result := str;
end;