Variablen "einsparen" <-> längere Befehlszeilen. Was ist sinnvoll?

[silver-moon-2000]

Hallo zusammen,

erstmal ein "Sorry" für den wenig aussagekräftigen Titel, aber mir fällt nichts besseres ein.
Zweitens, nochmal sorry, denn der Post ist, wie bei mir üblich, recht lang. Wer will, kann gleich zur Frage unten springen

Diesmal habe ich ausnahmsweise mal kein Problem, sondern nur eine Frage, die mich interessiert.
Es geht darum, ob man sich nicht hin und wieder Variablen einsparen kann, ohne dass die Lesbarkeit des Codes darunter leidet.
Das ist jetzt eigentlich auch kein reines Delphi Problem, sondern eher ein allgemeines programmiertechnisches Problem.

Als Beispiel nehme ich mal den neuen Thread Prämien her.

Ich will ausdrücklich sagen, dass ich niemanden in keinster Weise nicht kritisieren will, jeder hat seinen eigenen Programmierstil, das ist auch gut so.
Und jetzt habe ich eben eine Frage zu meinem...
Ich hoffe, man nimmt es mir nicht übel, wenn ich jetzt fremden Programmcode auseinanderklaube, doch die Frage stellt sich mir eigentlich regelmäßig.

Sir Rufo zum Beispiel schreibt in Antwort #5 des obengenannten Threads:

Delphi-Quellcode:

procedure TForm1.Button1Click( Sender : TObject );
var
  Dauer : integer;
  Praemie : Currency; //<-------
begin
  if TryStrToInt( Edit1.Text, Dauer ) then
    begin
      Praemie := PraemieBerechnen( Dauer );//<-------
      Edit3.Text := FloatToStr( Praemie );//<-------
    end
  else
    ShowMessage( Edit1.Text + ' ist keine gültige Zahl' );
end;

Wenn ich das ganze schreiben würde, sähe es so aus. Ich würde auf die Variable praemie verzichten.
(gut, ich würde auch auf TryStrToInt verzichten, aber das ist eine andere Baustelle )

Delphi-Quellcode:

procedure TForm1.Button1Click( Sender : TObject );
var
  Dauer : integer;
begin
  if TryStrToInt(Edit1.Text, Dauer) then
      Edit3.Text := FloatToStr(PraemieBerechnen(Dauer));//<-------
  else
    ShowMessage(Edit1.Text + ' ist keine gültige Zahl');
end;

Ich persönlich finde (natürlich ) meine Version etwas übersichtlicher, da eine Variable eingespart wird, bei der man sich, wenn man den Quellcode später wieder man ansieht, nicht fragen muss, was die eigentlich gleich wieder für eine Bedeutung hatte.
Auf der anderen Seite ist diese Befehlszeile zwar länger geworden, aber noch nicht so lang, dass man von "Spaghetticode" sprechen könnte.

Anders sähe es dann bei Edit3.Text := FloatToStr( PraemieBerechnen( StrToInt( Edit1.Text) ) ) ); aus, das zwar nochmals eine Variable einspart, aber nun wirklich doch ein wenig Denkeinsatz verlangt (vom TryStrToInt mal abgesehen).
Soll heißen, Variablen einsparen in Maßen macht meiner Meinung nach Sinn, solange man es nicht übertreibt und eine Befehlszeile quer über den Bildschirm läuft.

Zweites Beispiel, damit Sir Rufo nicht alleine leiden muss:
Popov schreibt im selben Thread (von mir auf die Stellen gekürzt, die mich interessieren):

Delphi-Quellcode:

type
  TPraemie = class
    private
      FBetriebsJahre: Word;
      function Berechnung: Currency;
    public
      property BetriebsJahre: Word read FBetriebsJahre write FBetriebsJahre;
      property Summe: Currency read Berechnung;
  end;


function TPraemie.Berechnung: Currency;
begin
  if FBetriebsJahre > 0 then
  //Prämie berechnen
end;

[...]

procedure TForm1.Button2Click(Sender: TObject);
var
  Praemie: TPraemie;
begin
  Praemie := TPraemie.Create;
  try
    Praemie.BetriebsJahre := StrToInt( Edit1.Text );
    Edit3.Text := FloatToStr( Praemie.Summe );
  finally
    Praemie.Free;
  end;
end;

Wenn ich wieder so frech bin, meine Version gegenüberzustellen, dann käme vermutlich etwas in der Art heraus:

Delphi-Quellcode:

type
  TPraemie = class
    private
      FBetriebsJahre: Byte;
    public
      function berechnePraemie(_betriebsjahre : Byte) : Currency;
  end;
[...]

function TPraemie.berechnePraemie(_betriebsjahre : Byte) : Currency;
begin
  FBetriebsjahre := _betriebsjahre;

  if FBetriebsJahre > 0 then
  //Prämie berechnen
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Praemie: TPraemie;
begin
  Praemie := TPraemie.Create;
  try
    Edit3.Text := FloatToStr(Praemie.berechnePraemie(StrToInt(Edit1.Text)));
  finally
    Praemie.Free;
  end;
end;

In dem Fall hätte ich also ein (oder zwei) Propertys eingespart.
Mir ist schon klar, dass sich Popovs und meine Version etwas unterscheiden, dass bei mir z.B. FBetriebsjahre nicht unabhängig von berechnePrämie(...) gesetzt werden kann.
Doch diese Funktionalität wird in Popovs Programm auch nicht benötigt.

Mit anderen Worten: Während Popovs Version insgesamt etwas mächtiger ist als meine, bewältigt meine Version die gleiche Aufgabe mit weniger Variablen / Properties. Für Sir Rufo gilt das gleiche analog.

Was ich vermeiden will (aber vermutlich dennoch erreicht habe), ist der Anschein, dass ich mich über die genannten Herren stellen will, dass ich also denken würde, mein Code sei besser als der Code der anderen. Das ist absolut nicht der Fall. Ich bin mir meines Status' als (blutiger) Anfänger durchaus bewusst und respektiere das Level der Andern.
gerade deswegen habe ich es aber als Vergleich herangezogen, getreu nach dem Motto: "Wer gut ist, kann nicht schlecht sein".

Weil ich also denke, dass die anderen guten Code schreiben, bin ich interessiert daran, wie sich meine Variante dagegen herausnimmt.

Oder anders formuliert: Warum lese ich häufig in diesem und anderen Foren die von Sir Rufo und Popov geschriebenen Varianten, in denen der Code mit "mehr" Variablen/Properties umgesetzt wird, wenn meiner Meinung nach die Lesbarkeit bei "moderatem" Variablen-Sparen nicht leidet?

Sorry nochmal an alle, die sich durch den Post gequält haben