string inkrementieren

[Neutral General]

merk dir wie viele Stellen der Barcode hatte. Dann umwandeln, erhöhen und dann mit Format und führenden 0en zurückwandeln.

Delphi-Quellcode:

function IncCode(Code: String): String;
var len: Integer;
    Val: Integer;
begin
  len := Length(Code);
  Val := StrToInt(Code);
  inc(Val);
  Result := Format('%.'+IntToStr(Len)+'d',[Val]);
end;

[Sir Rufo]

Zitat von Neutral General:

merk dir wie viele Stellen der Barcode hatte. Dann umwandeln, erhöhen und dann mit Format und führenden 0en zurückwandeln.

Delphi-Quellcode:

function IncCode(Code: String): String;
var len: Integer;
    Val: Integer;
begin
  len := Length(Code);
  Val := StrToInt(Code);
  inc(Val);
  Result := Format('%.'+IntToStr(Len)+'d',[Val]);
end;

Das geht doch so viel schicker:
Format( '%.*d', [ Len, Val ] ) .
SysUtils.Format

[ele]

Zitat von Sir Rufo:

Das geht doch so viel schicker:
Format( '%.*d', [ Len, Val ] ) .
SysUtils.Format

Da ist mal was, das ich noch nie gesehen habe. Ich kannte dieses Feature mit dem * noch nicht. Danke

[Coffeecoder]

Zitat von Sir Rufo;1104080
Das geht doch so viel schicker:
[DELPHI:

Format( '%.*d', [ Len, Val ] )[/DELPHI].
SysUtils.Format

Das erinnert mich an Reguläre Ausdrücke

[shmia]

Hier kommt die ultimative Funktion um einen String zu inkrementieren.
Dabei wird nicht auf Integer umgewandelt, sondern es wird alles nur durch reine Stringverarbeitung erledigt.
Das hat folgende Vorteile:
* kein Integer Überlauf möglich
* über eine Maske kann genau gesteuert werden, welche Positionen erhöht werden dürfen

Delphi-Quellcode:

{**************************************************************************
 * NAME:    IncrementWithMask
 * DESC:    erhöht eine Nummer (die als String vorliegt) um Eins
 *          Dabei darf "Number" an bestimmten Stellen auch Buchstaben enthalten
 *          "Mask" bestimmt, an welchen Positionen Ziffern oder Buchstaben erlaubt sind
 * Mask:  0 = Ziffern     (0..9)
 *        A = Buchstaben  (A..Z)
 *        Z = Ziffern & Buchstaben
 *        H = Hex-Ziffern  (0..9, A..F)
 *          = diese Stelle bleibt
 * PARAMS:  [-]
 * RESULT:  die erhöhte Nummer
 *************************************************************************}
function IncrementWithMask(const Number, Mask:string):string;

   function IncrementDigit(x:PChar; m:Char):Boolean;
   begin
      Result := False;
      case m of
         '0':
         begin
            x^ := Succ(x^);
            if x^ > '9' then
            begin
               x^ := '0';
               Result := True;
            end;
         end;
         'A':
         begin
            x^ := Succ(x^);
            if x^ > 'Z' then
            begin
               x^ := 'A';
               Result := True;
            end;
         end;
         'Z':
         begin
            if x^ = '9' then
               x^ := 'A'
            else if x^ = 'Z' then
            begin
               x^ := '0';
               Result := True;
            end
            else
               x^ := Succ(x^);
         end;

         'H':
         begin
            if x^ = '9' then
               x^ := 'A'
            else if x^ = 'F' then
            begin
               x^ := '0';
               Result := True;
            end
            else
               x^ := Succ(x^);
         end;

         ' ':
            Result := True;
      else
         raise Exception.CreateFmt('IncrementWithMask(%s, %s) - invalid Mask', [Number, Mask]);
      end;
   end;

var
   i : Integer;
begin
   Result := Number;
   for i := Length(Result) downto 1 do
   begin
      if not IncrementDigit(@result[i], Mask[i]) then
         Break;
   end;
end;

// Aufruf
neueNummer := IncrementWithMask(alteNummer, '00000000');

[Lannes]

so etwas ähnliches suche ich schon länger

Hast Du es noch etwas ultimativer irgendwo herumliegen?:

Delphi-Quellcode:

function IncrementWithMask(const Number, Mask:string, n: Integer):string;

//
alteNummer := 'Z024D00F';
neueNummer := IncrementWithMask(alteNummer, 'A000A00A', 10000);

[shmia]

Nun ja, man kann's ja mal so machen:
(die Performance bei hohen Werten von n ist natürlich nicht so berauschend)

Delphi-Quellcode:

function IncrementWithMask2(const Number, Mask:string, n: Integer):string;
begin
   Result := Number;
   while n > 0 do
   begin
     Result := IncrementWithMask(Result, mask); 
     Dec(n);
   end;
end;

[Lannes]

ja, wegen der Performance hatte ich nachgefragt.

Meine Versuche eine Funktion zu erstellen, die direkt um einen Wert per Pointer-Arithmetik erhöht, haben bisher leider nicht zum Ziel geführt.

Trotzdem Danke, habe meine bisherige durch Deine ausgetauscht, ich werde dann mal meine Bemühungen fortsetzen.

[shmia]

Zitat von Lannes:

Hast Du es noch etwas ultimativer irgendwo

Gibt es eigentlich eine Steigerung zu "ultimativer" ?

Delphi-Quellcode:

function FastCharPos(const S: AnsiString; const C: AnsiChar): Integer;
begin
  for Result := 1 to Length(S) do
    if S[Result] = C then
       Exit;
  Result := 0;
end;

function IncSingleDigit(var c:AnsiChar; n : Integer; const d:string):Integer;
var
   z : Integer;
   len : Integer;
begin
   len := length(d);
   z := FastCharPos(d, c) - 1;
   if z < 0 then z := 0;
   z := z + n;

   c := d[(z mod len) +1];
   Result := z div len;
end;

function IncBinary(var x:Byte; n : Integer):Integer;
var
   z : Integer;
begin
   z := Ord(x) + n;
   x := z and $FF;
   Result := z div 256;
end;

{**************************************************************************
 * NAME:    IncrementWithMask
 * DESC:    erhöht eine Nummer (die als String vorliegt) um den Wert N
 *          Dabei darf "Number" an bestimmten Stellen auch Buchstaben enthalten
 *          "Mask" bestimmt, an welchen Positionen Ziffern oder Buchstaben erlaubt sind
 * Mask:  0 = Ziffern     (0..9)
 *        2 = Binär       (0..1)
 *        A = Buchstaben  (A..Z)
 *        a = Buchstaben  (a..z)
 *        Z = Ziffern & Gross-Buchstaben
 *        z = Ziffern & Klein-Buchstaben
 *        H = Hex-Ziffern  (0..9, A..F)
 *        h = Hex-Ziffern  (0..9, a..f)
 *        B = Zeichen wird binär erhöht
 *          = diese Stelle bleibt
 * PARAMS:  [-]
 * RESULT:  die erhöhte Nummer
 * CHANGED: 03-06-2011/shmia
 *************************************************************************}
function IncrementWithMask(const Number, Mask:AnsiString; N : Integer):AnsiString;

   function IncrementDigit(x:PAnsiChar; m:Char; n:Integer):Integer;
   const
      digits :   AnsiString = '0123456789';
      alpha :    AnsiString = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
      hex :      AnsiString = '0123456789ABCDEF';
      numalpha : AnsiString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
   begin
      case m of
         '0': Result := IncSingleDigit(x^, n, digits);
         '2': Result := IncSingleDigit(x^, n, '01');
         'A': Result := IncSingleDigit(x^, n, alpha);
         'a': Result := IncSingleDigit(x^, n, LowerCase(alpha));
         'Z': Result := IncSingleDigit(x^, n, numalpha);
         'z': Result := IncSingleDigit(x^, n, LowerCase(numalpha));
         'H': Result := IncSingleDigit(x^, n, hex);
         'h': Result := IncSingleDigit(x^, n, LowerCase(hex));
         'B': Result := IncBinary(PByte(x)^,n);
         ' ':
            Result := n;
      else
         begin
            Result := n;
            x^ := m;
         end
      end;
   end;

var
   i : Integer;
begin
   Result := Number;
   UniqueString(Result);
   for i := Length(Result) downto 1 do
   begin
      N := IncrementDigit(@result[i], Mask[i], N);
      if N = 0 then
         Break;
   end;
end;

PS: Ohhjee, jetzt haben wir 2 Implementierungen

[Stevie]

epeen contest?