Warum String-Ausgaben mit format?

[Thanatos81]

Moin DP'ler!

Ich habe hier jetzt schon oft gesehen, dass Meldungen für showMessage und ähnliches mit format zusammengesetzt werden, also zB wie hier:

Delphi-Quellcode:

E.Message := format('Fehler beim Öffnen der Playlist-Datei <%s>'#13#10, [JvOpenDialog1.Filename]) + E.Message;

Und ich frage mich jedes Mal: "Warum?". Gibt es einen Geschwindigkeitsvorteil gegenüber folgender Variante?

Delphi-Quellcode:

E.Message := 'Fehler beim Öffnen der Playlist-Datei <%s>' + #13#10 + JvOpenDialog1.Filename + E.Message;

Oder gab es das einfach zusammenfügen von Strings per + unter Turbo/Borland Pascal ursprünglich nicht und es ist einfach eine Angewohnheit?

[mkinzler]

Es gibt halt oftmals mehre Wege nach Rom.

[Matze]

Hi,

der zweite Code macht etwas anderes. format ersetzt alle %s sukkzesive mit den Parametern, die folgen. Ich finde es oft übersichtlicher mit format und daher leichter wartbar.

[3_of_8]

Wenn man Format benutzt, ist es einfacher, Meldungen in Konstanten, Ressourcenstrings oder Sprachdateien auszulagern. Ansonsten müsstest du den String zerstückelt auslagern.

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

[turboPASCAL]

Zitat:

Zitat von Matze

... format ersetzt alle [z.B.] %s sukkzesive mit den Parametern, die folgen. Ich finde es oft übersichtlicher mit format und daher leichter wartbar.

Zitat:

Zitat von 3_of_8

... es einfacher, Meldungen in Konstanten, Ressourcenstrings oder Sprachdateien auszulagern. Ansonsten müsstest du den String zerstückelt auslagern.

dito.

[jmit]

Hallo,

Zitat:

Wenn man Format benutzt, ist es einfacher, Meldungen in Konstanten, Ressourcenstrings oder Sprachdateien auszulagern. Ansonsten müsstest du den String zerstückelt auslagern.

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

Gruß Jörg

[Balu der Bär]

Ist es nicht egal was man benutzt? Jeder wie er es möchte. ;)

[leddl]

Zitat:

Zitat von jmit

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

Aber du kannst ihn als einen String abspeichern ;)
Ansonsten müsstest du, falls zB. ein Wort mitten im Satz einzusetzen ist, 2 Strings speichern. Bei 2 einzusetzenden Worten könnten es dann schon 3 sein usw. ;)

[semo]

und man kennt es halt aus anderen programmiersprachen, siehe z.bsp. in C der befehlt printf(...) :-)

[DGL-luke]

Es ist auch für i18n (hey, endlich hab ich das mal angebracht :mrgreen:) 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:

Zitat von jmit

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

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

Delphi-Quellcode:

  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:

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:

Zitat von Alfi001

Zitat:

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 :gruebel: ? 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]

:gruebel: '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 :thumb:

Zitat:

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:

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:

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 ;) .

Delphi-Quellcode:

Format('Huhu%s', [ExclamationMark])

Delphi-Quellcode:

String.Format('Huhu{0}', exclamationMark);