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 :-D

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;

[himitsu]

Delphi-Quellcode:

function GetNum(S: String): Extended;
var
  i: Integer;
begin
  Result := 0;
  for i := 1 to Length(S) do
    if S[i] in ['0'..'9'] then begin
      Delete(S, 1, i - 1);
      Break;
    end;
  Val(S, Result, i);
end;

und nun noch'n bissl aufgemotzt

Delphi-Quellcode:

function GetNum(S: String): Extended;
var
  i: Integer;
begin
  Result := 0;
  for i := 1 to Length(S) do
    if S[i] in ['0'..'9'] then begin
      if (i > 1) and (S[i - 1] in ['+', '-']) then
        Delete(S, 1, i - 2) else Delete(S, 1, i - 1);
      Break;
    end;
  S := StringReplace(S, ',', DecimalSeparator, [rfReplaceAll]);
  Val(S, Result, i);
end;

[moelski]

Das wäre meine Variante:

Delphi-Quellcode:

Function Floaty(Input : String; DezSep : Char) : String;
var c          : Char;
    Thousand   : Char;
    len        : integer;
    Start      : Boolean;
    DezSepDone : Boolean;
  procedure Accept(c: char);
  begin
    inc(len);
    Result[len] := c;
  end;
begin
  len := 0; Start := False; DezSepDone := False;

  if DezSep = '.' then Thousand := ','
                  else Thousand := '.';

  SetLength(Result, Length(Input));
  for c in Input do begin
    if c in ['0' .. '9', '-', DezSep] then begin
      if (c = DezSep) and DezSepDone then Break;  // Bsp : 1.323,999,34 verhindern
      Start := len=0;             // Wenn erste Zahl hinzugefügt wird -> Start
      if c = DezSep then begin
        DezSepDone := True;   // DezimalSep wurde bearbeitet
        Accept(DecimalSeparator);
      end else
        Accept(c);
    end else begin
      if Start and (c <> Thousand) then Break;
    end;
  end;
  SetLength(Result, len);
end;

Floaty('Dies ist -1,323.999.34 jojo', '.') liefert -1323,999.

[jbg]

Zitat:

Zitat von Daniela.S (Beitrag 1043095)

SetLength( str, (Integer(p2) - Integer(str)) div 2 );

Na dann warte mal bis 64 Bit kommt, dann passt dein Integer-Typecast wieder nicht. Warum nicht einfach

Delphi-Quellcode:

SetLength( str, (p2 - PChar(str)) );

Damit passt das für ANSI, UNICODE und 64 Bit, 128 Bit, ... man weiß ja nie.

[Horst_]

Hallo,

@moelski:
Hänge doch bitte eine Beispieldatei an, damit man eine Tempovergleich der verschiedenen Versionen machen kann.

Gruß Horst