POS findet was das ich nicht verstehe... ?

[Furtbichler]

Zitat von Sir Rufo:

Die richtige Implementierung wäre...

Ich wusste nicht, das es richtig ist, wenn eine Funktion zwei Werte liefert: Einen 'Value' und einen Rückgabewert. Zudem wäre eine Erklärung, wie Du sie angibst, ja überflüssig, wenn der Code wirklich selbstdokumentierend wäre
Wie wäre es (beim Ansatz 'self documenting code') mit drei Funktionen?

Delphi-Quellcode:

Function HasParameter (const AText, AParamName : string) : Boolean;
Function GetOptionalParamValue (const AText, AParamName : string) : String;
Function GetMandantoryParamValue (const AText, AParamName : string) : String;

DAS wäre dann selbstdokumentierend. Finde ich.

[Sir Rufo]

Zitat von Garfield:

Zitat von Sir Rufo:

Die Basis ist aber immer TryStrToInt

Ich dachte val. Habe das auch genommen, weil es kein StrToUInt gibt.

Jupp, da wird als Basis die System-Funktion System.Val benutzt.
Der Code-Wert wird aber dort nur auf = 0 oder <> 0 ausgewertet, so dass man diese Teile auch problemlos so hätte deklarieren können:

Delphi-Quellcode:

function TryStrToInt( const S: string; out Value: Integer ) : Boolean;
var
  E: Integer;
begin
  Val(S, Value, E);
  Result := E = 0;
end;

function StrToInt(const S: string): Integer;
begin
  if not TryStrToInt(S, Result) then ConvertErrorFmt(@System.SysConst.SInvalidInteger, [S]);
end;

function StrToIntDef(const S: string; Default: Integer): Integer;
begin
  if not TryStrToInt(S, Result) then Result := Default;
end;

[Garfield]

Gut. Damit verstehe ich Dich.

[Sir Rufo]

Zitat von Furtbichler:

Zitat von Sir Rufo:

Die richtige Implementierung wäre...

Ich wusste nicht, das es richtig ist, wenn eine Funktion zwei Werte liefert: Einen 'Value' und einen Rückgabewert. Zudem wäre eine Erklärung, wie Du sie angibst, ja überflüssig, wenn der Code wirklich selbstdokumentierend wäre
Wie wäre es (beim Ansatz 'self documenting code') mit drei Funktionen?

Delphi-Quellcode:

Function HasParameter (const AText, AParamName : string) : Boolean;
Function GetOptionalParamValue (const AText, AParamName : string) : String;
Function GetMandantoryParamValue (const AText, AParamName : string) : String;

DAS wäre dann selbstdokumentierend. Finde ich.

Wenn du das so machst, dann bin ich direkt bei dir:

Delphi-Quellcode:

Function HasParameter (const AText, AParamName : string) : Boolean;
Function GetOptionalParamValue (const AText, AParamName, ADefault : string) : String; // ADefault fehlte
Function GetMandantoryParamValue (const AText, AParamName : string) : String;

und als Basis für alle kann man dann diese Funktion nutzen

Delphi-Quellcode:

function TryGetParamValue(const AText, AParamName : string; out Value : string ) : Boolean;
begin
  ...
end;

[Furtbichler]

Warte mal, dann braucht man doch nur zwei Funktionen: 'HasParameter' und 'GetParameter'. Fertig. 'GetParameter' wirft eine Exception, wenn der Parameter nicht zu finden ist und das Defaultzeugs kann man sich zusammenbauen:

Delphi-Quellcode:

Function GetOptionalParameter (const aText, aParam, aDefault : String) : String;
Begin
  if HasParameter (aParam, aText) then
    result := GetParameter (aText, aParam)
  else
    result := aDefault;
End;

So isses chön, ne?

[Sir Rufo]

Zitat von Furtbichler:

Warte mal, dann braucht man doch nur zwei Funktionen: 'HasParameter' und 'GetParameter'. Fertig. 'GetParameter' wirft eine Exception, wenn der Parameter nicht zu finden ist und das Defaultzeugs kann man sich zusammenbauen:

Delphi-Quellcode:

Function GetOptionalParameter (const aText, aParam, aDefault : String) : String;
Begin
  if HasParameter (aParam, aText) then
    result := GetParameter (aText, aParam)
  else
    result := aDefault;
End;

So isses chön, ne?

Dann implementiere diese beiden Methoden doch mal DRY und du kommst wieder bei TryGetParamValue raus

[Furtbichler]

Darum geht es nicht. Ich kann auch alles in eine Methode packen, die hochredundant ist, alles in einem Abwasch durchläuft und spuperduperperformant ist. Leider widersprechen sich Lesbarkeit und Performance häufig.

'Richtig' implementiert ist auch so eine Sache: Entweder gehe ich auf Lesbarkeit, Clean Code o.ä, oder eben auf 'richtig flott'. Hier dachte ich, es geht um Lesbarkeit, Das man in der konkreten Implementierung u.U. eine Codezeile doppelt ausführt, ist dann eben so und kein Verstoß gegen DRY. By DRY geht es ja um die Vermydung von Codeblockduplikaten, nicht von einfachen Aufrufen.

Delphi-Quellcode:

Function HasParameter (aText, aParam : String) : Boolean;
Begin
  Result := ParameterIndex (aText, aParam) > 0;
End;

Function GetParamValue(aText, aParam : String) : Boolean;
Begin
  i := ParameterIndex(aText, aParam);
  if i=0 then Raise Exception.Create('Parameter gibbet nich');
  Result := ReadValueStartingAtPos(aText, i);
End;

Na, issok?

[Sir Rufo]

Nun ja,

um den ParameterIndex zu ermitteln, muss der Text durch einen "Parser" (wo fängt der Wert zum Parameter an).
Um den ParameterWert zu ermitteln, muss der Text wieder durch einen "Parser" (wo hört der Wert zum Parameter auf).

Da das nicht nur sehr ähnlich ist (des Einen Ende ist des Anderen Anfang) würde ich das in einer Funktion implementieren.

Dann ist es der sogenannte DRY KISS

[Furtbichler]

Zitat von Sir Rufo:

Nun ja...Dann ist es der sogenannte DRY KISS

So so, wenn Du das so implementieren willst, bitte sehr.

Hier wird genau einmal geparst.

Delphi-Quellcode:

Function ParameterIndex (aText, aParam : String) : Integer;
Begin
  if ParamDictionary.Contains(aParam) then
    result := ParamDictionary[aParam]
  else begin
    result := FindParam(aText,aParam);
    ParamDictionary.Add(aParam, Result);
  end
end;

PS: Was ist eigentlich das Gegenteil von DRY KISS? Der WET FART?

Im Ernst: DRY ist ja ganz nett als Programmierparadigma. Aber wenn ich dann schlechter lesbaren Code produziere, dann muss ich mich entscheiden. Ich persönlich kann mit diesen kombinierten Sachen nichts anfangen. Und über den besten Code kann man vortrefflich streiten (oder ein Bier aufmachen).

Es kommt auf die Implementierung an. Wichtig ist, das ich vorne ein einfaches und minimales Interface habe. Was ich damit anstelle ('TryGet' etc.) ist dann etwas anderes.

Edit: Und natürlich ist der Ansatz, das ganze einmal zu parsen ('TryParse'), im Sinne von DRY optimal. Aber DRY ist nicht alles. Es gibt auch noch den 'Clean Code' Ansatz (dessen eine Facette DRY ist). Beides komplett unter einen Hut zu bekommen, ist manchmal nicht so leicht.

Letztendlich würde man hier den Parameter in den Vordergrund stellen, eine entsprechend Klasse entwicklen, die sich aus dem Text einmalig die Position ermittelt. Und dann diesem Parameter die hier vorgestellten Methoden 'Exists' (aka 'HasParameter') und 'Value' spendieren. Hier haben wir ja aus einer einfachen Idee ('Richtig machen') auf prozeduraler Ebene versucht, moderne Konzepte anzuwenden. Das geht nicht ohne Weiteres.