Warum String-Ausgaben mit format?

[DGL-luke]

Es ist auch für i18n (hey, endlich hab ich das mal angebracht ) praktisch unschlagbar. Denn dort speicherst du für deutsch "%1s wurde von %2s gebaut", im englischen willst/musst du aber vielleicht den satz komplett umdrehen: "%2s built %1s". Mit deiner string-aneinanderhäng-methode wird das schwierig.

[Ralf Kaiser]

Zitat von jmit:

Der String sieht irgendwie doch genau so zerstückelt aus.

Hi,

stell dir vor du willst solch einen String als Resourcestring speichern um ihn hinterher einem Übersetzer zu geben der die Oberfläche deines Programmes übesetzt:

"Sie haben %d Dateien zum löschen ausgewählt. %d von diesen %d Dateien konnten nicht gelöscht werden da sie %s"

Diesen String wir der Übersetzer verstehen und ohne Probleme verstehen und übersetzen können.

Anders, mit den Einzelstrings, würden diese so aussehen und für den Übersetzer fast unmöglich zu überseten sein, da sie vollkommen aus dem Zusammenhang gerissen wären:

"Sie haben"
"Dateien zum löschen ausgewählt."
"von diesen"
"Dateien konnten nicht gelöscht werden da sie"

Solche Satzfragmente wird kein Übersetzer übersetzen können.

Ciao,
Ralf

[negaH]

Format() ist

1.) sauber lesbar
2.) dadurch wird bei konsequenter Anwendung der komplette Source lesbarer
3.) was uns ein routiniertes Arbeiten ermöglicht und Routine in der Arbeit ist Professionalität da man Regeln aufstellt und diese einhält
4.) sehr effizient weil sehr universell benutzbar, zb. eben keine zerstückelten Strings ergo Resourcestring sind machbar, Parameter mit Formatierungsanweisungen und Inidizierten Parameterzugriffen ermöglicht

  Format('Test %1d, %2s, %1d', [12345, 'String']); fazit: wer behauptet das die Anwendung von Format(), auf Grund dessen das man auch einen String aus Teilstrings zusammenbauen kann, der ist ignorant. Denn der würde auch behaupten das Wasserrohre im Haushalt unsinnig sind denn man könnte auch dieses Wasser aus dem Brunnen holen und per Eimern schleppen.

Die Frage "Warum ist Format immer noch zu unflexibel, zb. im Vergleich zu printf() ?" wäre degegen viel cleverer gewesen

Gruß Hagen

[Ralf Kaiser]

Zitat von negaH:

Die Frage "Warum ist Format immer noch zu unflexibel, zb. im Vergleich zu printf() ?" wäre degegen viel cleverer gewesen

Stimmt!

Was mich an "Format" immer schon gestört hat ist die Tatsache, daß man keine Formatierungszeichen wie in prinf() verwenden kann: \t für Tab, \n für Newline usw.

Ciao,
Ralf

[SubData]

Code:

  Format('blah%sblubb', [#13]);

Ich glaube Chars kann man direkt in %s einsetzen, kann aber auch n gesondertes Zeichen gewesen sein, müsste ich mal nachsehen...

Is zwar nich ganz so schön, wie \n oder \r oder so, aber es geht auch

[Khabarakh]

Zitat von Alfi001:

Zitat von negaH:

Die Frage "Warum ist Format immer noch zu unflexibel, zb. im Vergleich zu printf() ?" wäre degegen viel cleverer gewesen

Stimmt!

Was mich an "Format" immer schon gestört hat ist die Tatsache, daß man keine Formatierungszeichen wie in prinf() verwenden kann: \t für Tab, \n für Newline usw.

Ciao,
Ralf

Was soll das denn mit Format/printf zu tun haben ? Escape-Sequences sind ein Compiler-Feature beim Parsen von String-Literalen, können also auch außerhalb von printf/... verwendet werden.
Nützlich sind sie natürlich trotzdem, auch wenn ich \n zuliebe der Plattformunabhängigkeit nicht benutze.

[DGL-luke]

'string'#9#13#10'string' sollte äquivalent zu "string\t\nstring" sein....

[alzaimar]

Übrigens spricht aus Nichts dagegen, Format zu erweitern bzw. neu zu implementieren. Der Code ist denkbar einfach:

Delphi-Quellcode:

// Hingehackt von Alzaimar irgendwann 2003
Function csFormat(aFormatStr: String; Arg: Array Of Variant): String;
Var
  i, p: Integer;

  Procedure _Format;
  Var
    j, n: Integer;
    r, fmt: String;

  Begin
    Inc(i);
    If aFormatStr[i] = '%' Then Begin
      Result := Result + aFormatStr[i];
      Inc(i)
    End
    Else Begin
      If aFormatStr[i] In ['0'..'9'] Then Begin
        j := i; While aFormatStr[i] In ['0'..'9', '*'] Do Inc(i);
        N := StrToIntDef(Copy(aFormatStr, j, i - j), -1);
        If aFormatStr[i] = ':' Then     // Index specifier
          p := N
        Else i := j;
      End;
      j := i;
      If aFormatStr[i] = '-' Then Inc(i);
      While aFormatStr[i] In ['0'..'9', '*'] Do Inc(i);
      If aFormatStr[i] = '.' Then Inc(i);
      While aFormatStr[i] In ['0'..'9', '*'] Do Inc(i);
      Inc(i);
      fmt := '%' + Copy(aFormatStr, j, i - j);
      Case upcase(aFormatStr[i - 1]) Of
        'D', 'U', 'X':
          r := Format(fmt, [integer(Arg[p])]);
        'F', 'E', 'G', 'N', 'M':
          r := Format(fmt, [Double(Arg[p])]);
      Else
        r := Format(fmt, [Arg[p]]);
      End;

      Result := Result + r;
      Inc(p);
    End
  End;

Begin
  i := 1;
  p := Low(Arg);
  Result := '';
  While i <= Length(aFormatStr) Do
    If aFormatStr[i] = '%' Then
      _Format
    Else {Hier käme der Code für \n \t etc. rein else } Begin
      Result := Result + aFormatStr[i];
      Inc(i)
    End;
End;

NB: Eventuell fehlt etwas, und nicht 100% kompatibel, da die Argumente als 'Variant Array' und nicht als 'Array Of Const' übergeben werdem. Ist aber leicht anzupassen, nur sind die 'Array Of Const' etwas umständlicher zu handhaben.

[Thanatos81]

Erst mal Danke für alle Antworten Die DP ist halt doch mehr als ein Forum zum Lösen von Problemen, hier lässt es sich auch trefflich diskutieren

Zitat von negaH:

wer behauptet das die Anwendung von Format(), auf Grund dessen das man auch einen String aus Teilstrings zusammenbauen kann, der ist ignorant.

Hab ich ja nie behauptet. Mir war bis zu diesem Thread nur nicht bewusst wie mächtig format ist und welche Vorteile es gegenüber dem manuellen Zusammenseten von Strings hat. Deswegen ja auch meine ursprüngliche Frage Und danke allen fürs Augen öffnen

Zitat von Khabarakh:

Ich setze schon bei den simpelsten Gelegenheiten Format ein, weil es einfach auch schon dort die Lesbarkeit erhöht. Die paar Zeichen Schreibaufwand mehr sind mir relativ dazu ziemlich Wurscht .

Lesbarkeit liegt meiner Meinung nach bis zu einem gewissen Maße auch im Auge des Betrachters bzw. ist Gewohnheitssache. Für mich z.B. sind format-Anweisungen im Moment noch noch unübersichtlicher, da ich noch nicht viel damit gemacht habe. Der Mensch ist halt ein Gewohnheitstier.

[Khabarakh]

Zitat von Thanatos81:

Lesbarkeit liegt meiner Meinung nach bis zu einem gewissen Maße auch im Auge des Betrachters bzw. ist Gewohnheitssache.

Jupp, wobei es auch übersichtlichere und weniger übersichtlichere Format-Varianten gibt .
Format('Huhu%s', [ExclamationMark]) String.Format('Huhu{0}', exclamationMark);