String vorne mit Nullen auffüllen

[himitsu]

@mytbo: statt Result.Create besser string.Create verwenden.

Du erzeugst einen neuen String und mit dem Result hat es eigentlich garnichts zu tun, abgesehn von dem Typ dieser Variable.

Funktionell geht es hier zwar, aber syntaktisch ist es eher fragwürdig missverständlich und in anderen Fällen auch fehleranfällig.


Zum Glück ist es hier aber kein schlimmer "Fehler".

Anders sieht es z.B. bei dem anderen syntaktisch gleichen Problem aus, wo es bei sowas ganz böse knallen kann/wird.
MyClass.Create anstatt TMyClass.Create aka Variable.Create anstatt Class.Create, weil hier kommt der Typ aus dem, auf was die Variable zeigt und nicht aus der Variablen-Deklaration selber.


@Walter:

In mytbo's Code, entspricht die Schleife dem StringOfChar bzw string.Create
und die ganze Funktion entspricht dem PadLeft.

Vorallem die Schleife, bzw. die unnötig vielen String-Operationen darin, sind eher suboptimal.

Man kann es machen, aber man kann auch die manuellen Codes durch etwas ersetzen, was es bereits fertig gibt. (vor allem, da Diese hier sogar optimaler arbeiten)

[mytbo]

Zitat von himitsu:

Vorallem die Schleife, bzw. die unnötig vielen String-Operationen darin, sind eher suboptimal.

Ich glaube, da ist dir ein Zuordnungsfehler bezüglich des Autors unterlaufen. In meiner Lösung gibt es keine Schleife und die in StringOfChar() ist OK.

Bis bald...
Thomas

[Uwe Raabe]

Zitat von DieDolly:

Delphi-Quellcode:

function AddLeadingZeroes(const aNumber, aFinalLength: Integer): string;
begin
 Result := System.SysUtils.Format('%.*d', [aFinalLength, aNumber]);
end;

Das funktioniert aber nur mit Zahlen. Der Titel spricht aber von String.

[himitsu]

Upss. (ein Zwerg)

Joar, aber der String heißt "Nummer"
OK, fast überall ist er dennoch ein String.

[KodeZwerg]

Zitat von mytbo:

da ist dir ein Zuordnungsfehler bezüglich des Autors unterlaufen

Bekenne mich Schuldig im Sinne der Anklage

Zitat von himitsu:

Upss. (ein Zwerg)

Der Zwerg kann auch ohne Schleife

Delphi-Quellcode:

function FillString(const AString: AnsiString; const AChar: AnsiChar; const ALength: Integer): AnsiString;
var
  Len: Integer;
begin
  Len := ALength - Length(AString); // padding "berechnen"
  if (Len > 0) then // kurzer check
    begin
      SetLength(Result, ALength); // länge setzen
      FillChar(Result[1], Len, AChar); // padding einfügen
      Move(AString[1], Result[Succ(Len)], Length(AString)); // zusammenfügen
    end
    else
      Result := AString; // das original so belassen
end;

Rein historisch betrachtet ist es sehr schnell.
Ich bete das mir da kein Fehler unterlaufen ist

[Rolf Frei]

Das mit dem Fillchar und dem String war mir beim schreiben ganicht aufgefallen, ist aber natürlich korrekt. Fillchar darf hier nicht verwendet werden. Da gibt es eine andere Funktion "StringOfChar()" dafür:

Delphi-Quellcode:

function FillString(const AString: String; AChar: Char; ALength: integer): String;
var i:integer;
begin
  Result := StringOfChar(AChar, ALength);
  Result := copy(AString, 1, ALength) + copy(Result, ALength - Length(AString), ALength);
end;

[Dennis07]

Zitat von KodeZwerg:

Der Zwerg kann auch ohne Schleife

Najaaaa, wenn du die Schleife einfach nach "Move" auslagerst, dann ja.

Zitat von KodeZwerg:

Delphi-Quellcode:

function FillString(const AString: AnsiString; const AChar: AnsiChar; const ALength: Integer): AnsiString;
var
  Len: Integer;
begin
  Len := ALength - Length(AString); // padding "berechnen"
  if (Len > 0) then // kurzer check
    begin
      SetLength(Result, ALength); // länge setzen
      FillChar(Result[1], Len, AChar); // padding einfügen
      Move(AString[1], Result[Succ(Len)], Length(AString)); // zusammenfügen
    end
    else
      Result := AString; // das original so belassen
end;

Jo, aber wieso nicht einfach:

Delphi-Quellcode:

function FillString(const AString: AnsiString; const AChar: AnsiChar; const ALength: Integer): AnsiString;
var
  Len: Integer;
begin
  Len := ALength - Length(AString);
  Result := StringOfChar(AChar, Len) + AString;
end;

Das klappt dann nebenbei auch mit UnicodeString.

[KodeZwerg]

@Dennis07 Weil meine AnsiString Variante um ein dutzendfach schneller ist.

[himitsu]

per se ist AnsiString und String/UnicodeString gleich schnell, bzüglich der Speicherverwaltung, da sie intern identisch sind.

Man darf nur nicht das *2 bzw. *SizeOf(WideChar) vergessen



Wenn mann will, dann kann man in einen AnsiString auch Unicode rein tun (CP_UTF16)
und andersrum auch ANSI in einen UnicodeString (auch wenn ich Letzteres nicht empfehlen würde).

[KodeZwerg]

Zitat von Dennis07:

Delphi-Quellcode:

function FillString(const AString: AnsiString; const AChar: AnsiChar; const ALength: Integer): AnsiString;
var
  Len: Integer;
begin
  Len := ALength - Length(AString);
  Result := StringOfChar(AChar, Len) + AString;
end;

Das klappt dann nebenbei auch mit UnicodeString.

Wenn Du aus AnsiString ein WideString bzw nur String machst glaube ich Dir das sofort

//edit
und der AnsiChar sollte dann natürlich ein WideChar bzw nur Char sein