Resultate langer Codezeilen zwischenspeichern?

Programmiersprachen, APIs, Bibliotheken, Open Source Engines, Debugging, Quellcode Fehler und alles was mit praktischer Programmierung zu tun hat.
Antworten
Benutzeravatar
BeRsErKeR
Establishment
Beiträge: 689
Registriert: 27.04.2002, 22:01

Resultate langer Codezeilen zwischenspeichern?

Beitrag von BeRsErKeR »

Hallo zusammen,

ich habe mal eine ganz allgemeine Frage in die Runde. Wie geht ihr mit folgendem Problem um:

Man möchte etwas berechnen, konkatenieren, etc. und der Ausdruck dafür ist etwas länglich. Das Ergebnis nutzt man nur an einer Stelle (z.B. übergibt man es an eine Funktion). Ist für euch hier Lesbarkeit wichtig oder die Tatsache, dass eine temporäre Variable unnötig ist?

Nehmen wir mal folgendes Beispiel (Pseudocode):

Code: Alles auswählen

print("Extreeeeeeeeeeeeeeem lange Konkatenation" + 123456.ToString() + eineFunktion("blub") + "noch viel mehr Text" + undNochEineFunktion(x, y, z) + "usw");
Hier wäre ja auch folgendes möglich (was hier sinnlos erscheint, aber print könnte ja auch mehrere konkatenierte Strings schlucken):

Code: Alles auswählen

string foo = "Extreeeeeeeeeeeeeeem lange Konkatenation" + 123456.ToString() + eineFunktion("blub") + "noch viel mehr Text" + undNochEineFunktion(x, y, z) + "usw";
print(foo);
oder

Code: Alles auswählen

string foo = "Extreeeeeeeeeeeeeeem lange Konkatenation";
foo += 123456.ToString();
foo += eineFunktion("blub");
...
print(foo);
Würde mich mal interessieren. Mir ist das gerade mal wieder beim Zusammenbauen von Exception-Texten für einen Parser aufgefallen. Das wird dann schnell unübersichtlich. Ok in dem Fall könnte man Fehlermeldungen eventuell auch statisch irgendwo ablegen, aber mir ist halt prinzipiell mal die Frage in den Sinn gekommen. Gibt sicherlich auch bessere Beispiele wo das oben genannte eine Rolle spielt.

Das gleiche Prinzip gilt ja auch für Verschachtelungen. Mal ein konkretes Beispiel (C#):

Code: Alles auswählen

throw new FormatException("Invalid group definition",
    new FormatException("Character " + next + "('"
        + group_string[next] + "') is invalid, expected ',' or '%'"));
Das steht noch hinter einem default: eines switch-Blocks. Das ist in meinen Augen schon unübersichtlich.
Ohne Input kein Output.
Benutzeravatar
xq
Establishment
Beiträge: 1581
Registriert: 07.10.2012, 14:56
Alter Benutzername: MasterQ32
Echter Name: Felix Queißner
Wohnort: Stuttgart & Region
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von xq »

Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?
Für C# (was es ja augenscheinlich ist) wäre das so:

Code: Alles auswählen

foo(string.Format(
    "Extreeeeeeeeeeeeeeem lange Konkatenation{0}{1}noch viel mehr Text{2}usw",
    123456,
    eineFunktion("blub"),
    undNochEineFunktion(x, y, z)));
Durch das Zeileneinrücken wird das ganze nicht so lang und durch den Format-Parameter richtig schön lesbar.
Außerdem ist ein .ToString() nicht nötig.
War mal MasterQ32, findet den Namen aber mittlerweile ziemlich albern…

Programmiert viel in ⚡️Zig⚡️ und nervt Leute damit.
Benutzeravatar
FlorianB82
Beiträge: 70
Registriert: 18.11.2010, 05:08
Wohnort: Darmstadt
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von FlorianB82 »

BeRsErKeR hat geschrieben:

Code: Alles auswählen

string foo = "Extreeeeeeeeeeeeeeem lange Konkatenation";
foo += 123456.ToString();
foo += eineFunktion("blub");
...
print(foo);
Definitiv so. Das wichtigste ist - mir zumindest - die einfache und schnelle Lesbarkeit des Programmtextes. Daraus ergibt sich unmittelbar ein einfacheres und (bei komplizierten Algorithmen auch besseres) Verständnis des Textes. Meiner Erfahrung nach zieht das weitere Vorteile wie einfacheres Debugging, einfacheres Refactoring, einfachere Zusammenarbeit zwischen mehreren Programmierern, sowie weniger Fehler oder Ungeschicklichkeiten nach sich.

Beispielsweise rufe ich in C++ auch gern die Stream-Operatoren einzeln auf dem Zielobjekt auf, statt durch Chaining eine einzige lange Zeile zu erzeugen, die danach kaum mehr zu überblicken und nur im Ganzen zu debuggen ist.

Und nebenbei: Das Builder-Pattern geht da ja in eine ähnliche Richtung.
Zuletzt geändert von FlorianB82 am 02.03.2014, 19:27, insgesamt 1-mal geändert.
Benutzeravatar
FlorianB82
Beiträge: 70
Registriert: 18.11.2010, 05:08
Wohnort: Darmstadt
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von FlorianB82 »

MasterQ32 hat geschrieben:Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?
Ich kenne mich nur in C++ gut aus, aber eventuell ist es ja auch in C# von Relevanz:

Ich versuche die sprintf()-Funktion zu meiden, da man einfach zu viele Fehler machen kann (falsche specifiers, falsche Parameteranzahl, falsche Puffergröße). Am angenehmsten finde ich, per std::sstream und dessen Operatoren den String zusammenzubauen - ganze ohne die genannten Fallstricke.

Aus Leserlichkeitsgründen einfache Konkatenationen durch sprintf()-Aufrufe austauschen zu wollen, empfinde ich persönlich eher als Schritt in die falsche Richtung.
Benutzeravatar
xq
Establishment
Beiträge: 1581
Registriert: 07.10.2012, 14:56
Alter Benutzername: MasterQ32
Echter Name: Felix Queißner
Wohnort: Stuttgart & Region
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von xq »

FlorianB82 hat geschrieben:
MasterQ32 hat geschrieben:Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?
Ich kenne mich nur in C++ gut aus, aber eventuell ist es ja auch in C# von Relevanz:

Ich versuche die sprintf()-Funktion zu meiden, da man einfach zu viele Fehler machen kann (falsche specifiers, falsche Parameteranzahl, falsche Puffergröße). Am angenehmsten finde ich, per std::sstream und dessen Operatoren den String zusammenzubauen - ganze ohne die genannten Fallstricke.

Aus Leserlichkeitsgründen einfache Konkatenationen durch sprintf()-Aufrufe austauschen zu wollen, empfinde ich persönlich eher als Schritt in die falsche Richtung.
Ist in C# durch string.Format wesentlich einfacher, da jedes Objekt eine ToString-Methode bietet. Einziges was einem passieren kann, sind falsche Parameterzahl, da wird dir aber beim ersten Call gleich eine sinnvolle Exception geworfen. Viele Methoden sind auch in der Standard-Lib schon so implementiert (WriteLine kann string, string + params, ...)
War mal MasterQ32, findet den Namen aber mittlerweile ziemlich albern…

Programmiert viel in ⚡️Zig⚡️ und nervt Leute damit.
Benutzeravatar
BeRsErKeR
Establishment
Beiträge: 689
Registriert: 27.04.2002, 22:01

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von BeRsErKeR »

MasterQ32 hat geschrieben:Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?
Für C# (was es ja augenscheinlich ist) wäre das so:

Code: Alles auswählen

foo(string.Format(
    "Extreeeeeeeeeeeeeeem lange Konkatenation{0}{1}noch viel mehr Text{2}usw",
    123456,
    eineFunktion("blub"),
    undNochEineFunktion(x, y, z)));
Durch das Zeileneinrücken wird das ganze nicht so lang und durch den Format-Parameter richtig schön lesbar.
Außerdem ist ein .ToString() nicht nötig.
Hmm aber wo ist hier der Vorteil gegenüber diesem Code?

Code: Alles auswählen

foo("Extreeeeeeeeeeeeeeem lange Konkatenation" +
    123456 +
    eineFunktion("blub") +
    "noch viel mehr Text" +
    undNochEineFunktion(x, y, z) +
    "usw");
Ok es sind weniger Zeilen, aber dafür hast du ja wieder eine längere Zeile. Wenn der Format-Text noch länger wird, musst du wieder irgendwo umbrechen.

Was ich auch als Problem sehe sind Verschaltelungen von Funktionaufrufen. Zum Beispiel sowas:

Code: Alles auswählen

foo("Extreeeeeeeeeeeeeeem lange Konkatenation" +
    123456 +
    eineFunktion("blub" + nochEinFunktionMitLangemNamen(123456) + "foobar" + foo("thereisalotmoretext" + "abc123" + someOtherFunc(x, y, z))) +
    "noch viel mehr Text" +
    undNochEineFunktion(x, y, z) +
    "usw");
Normalerweise breche ich nach einer gewissen Anzahl an Zeichen um (nach Augenmaß). Aber hier ist dann nicht mehr klar wo ich trenne. Wenn eine Zeile auf ein + folgt, dann kann das zu einer beliebigen Parameterliste gehören.

@Florian: Ok danke. Ich denke ähnlich wobei ich bislang aus Faulheit einfach nur hübsch umgebrochen habe.
Ohne Input kein Output.
Benutzeravatar
xq
Establishment
Beiträge: 1581
Registriert: 07.10.2012, 14:56
Alter Benutzername: MasterQ32
Echter Name: Felix Queißner
Wohnort: Stuttgart & Region
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von xq »

Der Vorteil ist, dass du deinen String einfach in ein Literal packst und fertig. Heißt, später steht da sowas:

Code: Alles auswählen

string sinnvollerName1 = eineFunktion(...);
foo(string.Format(
    fooFormatString, // Besserer Name hier einfügen
    123456,
    sinnvollerName1,
    undNochEineFunktion(x, y, z)));
So bleibt der Code immer bei max. einer Call-Verschachtelung. Muss man halt schauen, wie genau man das löst. Aber sag uns doch mal ein konkretes Beispiel, wo so ein langer Code anfällt, ich hab selten so lange Zeilen in meinem Code, auch für String-Konkatenation (für das man eigentlich einen StringBuilder nehmen sollte)
War mal MasterQ32, findet den Namen aber mittlerweile ziemlich albern…

Programmiert viel in ⚡️Zig⚡️ und nervt Leute damit.
Benutzeravatar
dot
Establishment
Beiträge: 1734
Registriert: 06.03.2004, 18:10
Echter Name: Michael Kenzel
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von dot »

Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";
Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)
Benutzeravatar
BeRsErKeR
Establishment
Beiträge: 689
Registriert: 27.04.2002, 22:01

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von BeRsErKeR »

MasterQ32 hat geschrieben:Der Vorteil ist, dass du deinen String einfach in ein Literal packst und fertig. Heißt, später steht da sowas:

Code: Alles auswählen

string sinnvollerName1 = eineFunktion(...);
foo(string.Format(
    fooFormatString, // Besserer Name hier einfügen
    123456,
    sinnvollerName1,
    undNochEineFunktion(x, y, z)));
So bleibt der Code immer bei max. einer Call-Verschachtelung. Muss man halt schauen, wie genau man das löst. Aber sag uns doch mal ein konkretes Beispiel, wo so ein langer Code anfällt, ich hab selten so lange Zeilen in meinem Code, auch für String-Konkatenation (für das man eigentlich einen StringBuilder nehmen sollte)
Versteh ich nicht. Der einzige Unterschied zu meinem Code ist, dass du anstatt eines '+' ein ',' schreibst und dass du drumrum noch die String.Format-Funktion hast. Ansonsten gibt es keinen Unterschied angesichts Verschachtelung oder Codelänge. Wenn ich in deinem Beispiel Funktionen als Parameter der Format-Funktion habe, die auch wieder lang sind, muss ich alles vorher in Variablen speichern. Das kann ich bei meiner Variante aber genauso machen. Die Konkatenation mit + Operator ist in meinen Augen identisch zu der Format-Funktion. Sie bringt also aus meiner Sicht keinen Vorteil.

dot hat geschrieben:Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";
Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)
Ein stringstream ist ja auch nichts anderes als die Stringkonkatenation in C#. Jedenfalls von der Funktionalität her und auch von der Codelänge. Auch in deinem Beispiel hast du ein Problem wenn z.B. eineFunktion wieder eine sehr lange Parameterliste aufweist bzw. einen Parameter schluckt, der wiederum zusammengebaut wird.
Ohne Input kein Output.
Benutzeravatar
dot
Establishment
Beiträge: 1734
Registriert: 06.03.2004, 18:10
Echter Name: Michael Kenzel
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von dot »

BeRsErKeR hat geschrieben:
dot hat geschrieben:Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";
Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)
Ein stringstream ist ja auch nichts anderes als die Stringkonkatenation in C#. Jedenfalls von der Funktionalität her und auch von der Codelänge. Auch in deinem Beispiel hast du ein Problem wenn z.B. eineFunktion wieder eine sehr lange Parameterliste aufweist bzw. einen Parameter schluckt, der wiederum zusammengebaut wird.
Ein stringstream ist etwas fundamental anderes als Stringkonkatenation, ganz besonders in C#, wo Strings immutable sind. Viel eher entspricht stringstream dem .NET StringBuilder.

Das Ganze lässt sich auch in weitere Funktionen aufspalten, man kann den stringstream ja beliebig herumreichen. Außerdem hat man natürlich die ganze Palette an Techniken inklusive I/O Manipulatoren und custom Streamoperatoren zur Verfügung...
Zuletzt geändert von dot am 03.03.2014, 12:40, insgesamt 2-mal geändert.
EyDu
Establishment
Beiträge: 100
Registriert: 24.08.2002, 18:52
Wohnort: Berlin
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von EyDu »

String Formatting hat gegenüber einfacher Konkatenation oder Streams einige Vorteile. So steht der Formatstring im Fokus der Formatierung, so dass die Vorlage wie normaler Text gelesen werden kann. Wenn man etwas am Format umstellen kann, dann muss man sich nicht erst durch die ganzen Einzelteile kämpfen, sondern ändert einfach nur den String.

Ein weiterer Vorteil ist, dass die Reihenfolge der Parameter immer gleich bleiben kann. Diese muss nie geändert werden. Werden die Parameter im Formatstring mittels "{0}", "{1}" etc. referenziert (oder bei Manchen Sprachen auch über den Namen, was natürlich sehr praktisch ist), dann kann die Formatierung beliebig umgestellt werden. Aus "{0} + {1} = {2}" kann man dann problemlos auch "{2} = {0} + {1}" machen. Mit Konkatenation und Streams muss hingegen die ganze Anweisung umgestellt werden.

Im Vergleich zur Konkatenation kommt dann noch hinzu, dass die Konstruktion mittels String Formatting linear ist. Werden die Strings mittels + zusammengefügt, so ergibt sich schnell quadratische Laufzeit. Gut, bei kleinen Strings ist das meistens egal, da wird der Vorteil (am Ende bei der Laufzeit) durch das Parsen des Strings aufgehoben.

Und dann ist es natürlich noch ganz angenehm, dass die Formatierungsparameter direkt in den Formatstring eingebaut werden können. Mittels Konkatenation ist so etwas einfach nur hässlich, mit Streams mindestens aber anstrengend.
Benutzeravatar
xq
Establishment
Beiträge: 1581
Registriert: 07.10.2012, 14:56
Alter Benutzername: MasterQ32
Echter Name: Felix Queißner
Wohnort: Stuttgart & Region
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von xq »

@EyDu: Danke, ich habs nicht auf die Reihe bekommen, das auszudrücken :P
Zudem ist Lokalisierung des ganzen easy, da du nur einen String speichern musst und nicht viele Teilstrings. Außerdem kannst du ja auch die Satzstellung in versch. Sprachen ändern und zum Beispiel Werte einfach wo anders hinsetzen, wo du aber kein Konkatenation wieder für jede Sprache einen neuen Aufruf bräuchtest.
Grüße
War mal MasterQ32, findet den Namen aber mittlerweile ziemlich albern…

Programmiert viel in ⚡️Zig⚡️ und nervt Leute damit.
Benutzeravatar
BeRsErKeR
Establishment
Beiträge: 689
Registriert: 27.04.2002, 22:01

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von BeRsErKeR »

dot hat geschrieben:
BeRsErKeR hat geschrieben:
dot hat geschrieben:Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";
Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)
Ein stringstream ist ja auch nichts anderes als die Stringkonkatenation in C#. Jedenfalls von der Funktionalität her und auch von der Codelänge. Auch in deinem Beispiel hast du ein Problem wenn z.B. eineFunktion wieder eine sehr lange Parameterliste aufweist bzw. einen Parameter schluckt, der wiederum zusammengebaut wird.
Ein stringstream ist etwas fundamental anderes als Stringkonkatenation, ganz besonders in C#, wo Strings immutable sind. Viel eher entspricht stringstream dem .NET StringBuilder.

Das Ganze lässt sich auch in weitere Funktionen aufspalten, man kann den stringstream ja beliebig herumreichen. Außerdem hat man natürlich die ganze Palette an Techniken inklusive I/O Manipulatoren und custom Streamoperatoren zur Verfügung...
Es geht mir nicht um die Funktionalität, sondern um die Lesbarkeit / Übersichtlichkeit von langen Ausdrücken. Ich glaube wir fokussieren uns hier zu sehr auf Strings. Wie gesagt besteht das gleiche Problem auch bei langen Termen usw.

Mich würde z.B. ein konkretes Beispiel interessieren, wo ein Stream bei Verschachtelungen einen Vorteil bringt (vom Umfang des Codes her, nicht von Effizienz oder ähnlichem). Ich könnte mir vorstellen, dass jede Funktion einen Stream frisst und dort selbst ihr Zeugs hinzupackt. Aber das geht ja dann auch nur wenn man die Funktion selbst schreiben kann, was nicht immer der Fall ist. Und Extrawrapper finde ich dann wieder etwas zu over-the-top.

Und wie gesagt löst ein Stream nicht das Problem wenn mathematische Operationen zu lang oder zu verschachtelt werden.

EyDu hat geschrieben:String Formatting hat gegenüber einfacher Konkatenation oder Streams einige Vorteile. So steht der Formatstring im Fokus der Formatierung, so dass die Vorlage wie normaler Text gelesen werden kann. Wenn man etwas am Format umstellen kann, dann muss man sich nicht erst durch die ganzen Einzelteile kämpfen, sondern ändert einfach nur den String.

Ein weiterer Vorteil ist, dass die Reihenfolge der Parameter immer gleich bleiben kann. Diese muss nie geändert werden. Werden die Parameter im Formatstring mittels "{0}", "{1}" etc. referenziert (oder bei Manchen Sprachen auch über den Namen, was natürlich sehr praktisch ist), dann kann die Formatierung beliebig umgestellt werden. Aus "{0} + {1} = {2}" kann man dann problemlos auch "{2} = {0} + {1}" machen. Mit Konkatenation und Streams muss hingegen die ganze Anweisung umgestellt werden.

Im Vergleich zur Konkatenation kommt dann noch hinzu, dass die Konstruktion mittels String Formatting linear ist. Werden die Strings mittels + zusammengefügt, so ergibt sich schnell quadratische Laufzeit. Gut, bei kleinen Strings ist das meistens egal, da wird der Vorteil (am Ende bei der Laufzeit) durch das Parsen des Strings aufgehoben.

Und dann ist es natürlich noch ganz angenehm, dass die Formatierungsparameter direkt in den Formatstring eingebaut werden können. Mittels Konkatenation ist so etwas einfach nur hässlich, mit Streams mindestens aber anstrengend.
Wie schon gesagt. Es geht hier nicht darum ob ein String Formatting besser oder effizienter ist. Es geht hier einzig darum, wie man lange Codezeilen ausdrückt. Als Einzeiler, als Mehrzeiler mit Umbrüchen oder als Mehrzeiler mit Einzelzuweisungen. Wie gesagt kommt am besten mal weg von Strings. Denkt euch einfach eine lange Operation wie 132473284 + 2343324 - myvarname * foobar(123456, pow(2, 6000) + 284943854 - 99999999) + ... + einige_verschaltelungen_spaeter - ...
Ohne Input kein Output.
EyDu
Establishment
Beiträge: 100
Registriert: 24.08.2002, 18:52
Wohnort: Berlin
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von EyDu »

BeRsErKeR hat geschrieben:Wie schon gesagt. Es geht hier nicht darum ob ein String Formatting besser oder effizienter ist. Es geht hier einzig darum, wie man lange Codezeilen ausdrückt. Als Einzeiler, als Mehrzeiler mit Umbrüchen oder als Mehrzeiler mit Einzelzuweisungen. Wie gesagt kommt am besten mal weg von Strings. Denkt euch einfach eine lange Operation wie 132473284 + 2343324 - myvarname * foobar(123456, pow(2, 6000) + 284943854 - 99999999) + ... + einige_verschaltelungen_spaeter - ...
Ich gehe da in mehreren Schritten vor. Als erstes ziehe ich die Teilausdrücke heraus, welchen ein vernünftiger Namen zugeordnet sind. Lange Ketten von Operationen entstehen typischerweise ja nicht aus dem Nichts. Das kann man dann so lange rekursiv durchführen, bis keine vernünftigen Namen mehr machbar sind.

Wenn der erste Schritt noch nicht ausreicht, dann versuche ich die Teilausdrücke noch weiter zu zerlegen. Da bietet es sich natürlich an die Teile herauszuziehen, so dass die eigentliche Formel sichtbar wird:

Code: Alles auswählen

d = sqrt((x1 - x2)**2 + (y1 - y2)**2)
=>
a = x1 - x2
b = y1 - y2
d = sqrt(a**2 + b**2)
Häufig bleiben dann nur noch Teilausdrücke übrig, welche sehr ähnlich sind oder sich zum Teil überschneiden. Wenn es der Übersichtlichkeit dient, dann ziehe ich den Kram noch in Dummy-Variablen (oder einer einfachen Funktion) raus, sonst eben nicht.

Wenn keiner der vorherigen Schritte anwendbar ist, dann formatiere ich den Code üblicherweise nur um. Neue Zeilen mache ich üblicherweise abhängig von den Operatoren (üblicherweise der Stärke der Bindung), Parameter von Funktion breche ich um und die Reihenfolge der Ausdrücke ordne ich von weniger komplex bis komplex. Das alles eben mit entsprechender Einrückung:

Code: Alles auswählen

a*b + foo(2, bar(f, g, h), 42) + u*v
=>
a*b +
u*v +
foo(
    2,
    bar(
        f,
        g,
        h),
    42)
Wobei die Parameterliste natürlich nur dann umgebrochen wird, wenn es auch sinnvoll ist. In dem Beispiel würde man natürlich ``bar(f, g, h)`` in eine Zeile schreiben.

Klammersetzung versuche ich allgemein durch Einrückung hervorzuheben, das liest sich einfacher. Wie man nun die schließende Klammer setzt (ob hinter den letzten Wert oder einzeln in eine neue Zeile), hängt wohl stark vom eigenen Geschmack ist. Gleiches gilt für die Platzierung der Kommas oder (in diesem Beispiel) die verbindenden +-Operatoren. Am Ende der Zeile sehen sie schöner aus, vor der nächsten Zeile (also ``+ u*v``) sind sie natürlich etwas aussagekräftiger, dass das + zu ``u*v`` gehört und nicht zu ``a*b``.
RedGuy
Establishment
Beiträge: 111
Registriert: 17.09.2002, 17:27
Echter Name: Manuel Hofmann
Wohnort: Rottweil
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von RedGuy »

Hi !

Also mir geht es primär um Performanz, sekundär um die Lösung der Aufgabe. Letzteres bedeutet: Temporäre Variablen dann, wenn ich das für den Entwicklungsprozess benötige (z.B. [logische] Übersicht bei großen Sequenzen).

Aber zurück zu deinen anfänglichen Beispiel:

Anstatt der langen Zeile

Code: Alles auswählen

print("Extreeeeeeeeeeeeeeem lange Konkatenation" + 123456.ToString() + eineFunktion("blub") + "noch viel mehr Text" + undNochEineFunktion(x, y, z) + "usw");
würde ich einfach schreiben

Code: Alles auswählen

print("Extreeeeeeeeeeeeeeem lange Konkatenation"
                 + 123456.ToString()
                 + eineFunktion("blub")
                 + "noch viel mehr Text"
                 + undNochEineFunktion(x, y, z)
                 + "usw");
. Niemals würde ich für einen solchen Zweck temporäre Variablen oder String-Konkatenationen einsetzen!

PS: Sorry, dass ich den Thread erst jetzt entdeckt habe, aber wohl besser zu spät als niemals.


Gruss
RedGuy
Alexander Kornrumpf
Moderator
Beiträge: 2110
Registriert: 25.02.2009, 13:37

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von Alexander Kornrumpf »

RedGuy hat geschrieben:Also mir geht es primär um Performanz, sekundär um die Lösung der Aufgabe.
Wait, what?
Benutzeravatar
dot
Establishment
Beiträge: 1734
Registriert: 06.03.2004, 18:10
Echter Name: Michael Kenzel
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von dot »

RedGuy hat geschrieben:Niemals würde ich für einen solchen Zweck temporäre Variablen oder String-Konkatenationen einsetzen!
Deine Lösung verwendet aber Stringkonkatenation und erzeugt temporäre Objekte... ;)
Alexander Kornrumpf
Moderator
Beiträge: 2110
Registriert: 25.02.2009, 13:37

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von Alexander Kornrumpf »

dot hat geschrieben:
RedGuy hat geschrieben:Niemals würde ich für einen solchen Zweck temporäre Variablen oder String-Konkatenationen einsetzen!
Deine Lösung verwendet aber Stringkonkatenation und erzeugt temporäre Objekte... ;)
Stimmt, das ist witzig.
RedGuy
Establishment
Beiträge: 111
Registriert: 17.09.2002, 17:27
Echter Name: Manuel Hofmann
Wohnort: Rottweil
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von RedGuy »

Hi !

@dot: Ja tatsächlich, entschuldigung. Ich meinte allerdings nicht die im Beispiel notwendingen Konkatenationen (da ja Variablen konkateniert werden), sondern Konkatenationen im Darüberhinaus, wie z.B. Folgendes:

Code: Alles auswählen

string a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
            + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
Also eine Unterteilung von einem während der Programmierzeit bekannten strings.
.

Oder gar separate explizite temporäre Variablen:

Code: Alles auswählen

string a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
string b = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

string c = a + b;
Diese beiden Dinge meinte ich eigentlich.

@Alexander Kornrumpf:
was genau verstehst du nicht ?


Gruss
RedGuy
Zuletzt geändert von RedGuy am 15.05.2016, 13:03, insgesamt 1-mal geändert.
Benutzeravatar
dot
Establishment
Beiträge: 1734
Registriert: 06.03.2004, 18:10
Echter Name: Michael Kenzel
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von dot »

RedGuy hat geschrieben:@Alexander Kornrumpf:
was genau verstehst du nicht ?
Naja, es geht ihm wohl um deine Aussage, dass die Lösung der Aufgabe sekundär und die Performance für dich vorrangig ist. In dem Fall kann man aber auch einfach ein Programm schreiben, das nichts Anderes tut als sofort wieder returnen. Löst zwar nicht die Aufgabe, das dafür aber maximal performant... ;)
RedGuy
Establishment
Beiträge: 111
Registriert: 17.09.2002, 17:27
Echter Name: Manuel Hofmann
Wohnort: Rottweil
Kontaktdaten:

Re: Resultate langer Codezeilen zwischenspeichern?

Beitrag von RedGuy »

Hi !

@dot: Ich meine natürlich nicht die Tatsache der Lösung der Aufgabe, sondern den Entwicklungsprozess (z.B. Unterstützung für den Entwicklungsprozess).

Mit Unterstützung für den Entwicklungsprozess meine ich z.B. Folgendes:

Wenn man komplizierte Formeln hat, möchte man diese manchmal ungern in eine Zeile schreiben und noch dazu nur mit einem Variablennamen vergeben -trotz
dass mehrere Variablen rein logisch (von der Verwendung her) gesehen unnötig wären. Sondern man vergibt mehrere Zwischenvariablen und schreibt alles natürlich in mehrere Zeilen. Somit ist ein besserer Entwicklungsfluss gewährleistet.

Ich hoffe jetzt ist alles klar :)


Gruss
Red
Antworten