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

[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...

[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.