Die "richtige" Sourcecode Formatierung?

[Der schöne Günther]

Habt Ihr euch mal überlegt dass man im Endeffekt ganz andere Probleme hat wenn man anfangen muss 5-fach verschachtelte Bedingungen zu schreiben?

Beiträge wie dieser sind wahrscheinlich der Grund weshalb ich nirgendwo eingeladen werde

[DeddyH]

Zitat von Der schöne Günther:

Habt Ihr euch mal überlegt dass man im Endeffekt ganz andere Probleme hat wenn man anfangen muss 5-fach verschachtelte Bedingungen zu schreiben?

Beiträge wie dieser sind wahrscheinlich der Grund weshalb ich nirgendwo eingeladen werde

(abgesehen davon finde ich den ganzen Thread irgendwie müßig, jeder hat da seine eigenen Vorlieben).

[mm1256]

Zitat von DeddyH:

(abgesehen davon finde ich den ganzen Thread irgendwie müßig, jeder hat da seine eigenen Vorlieben).

Meine Worte im anderen Thread. Aber, interessant mal zu sehen, wie Andere ihren Code formatieren.

[bernau]

Zitat von mm1256:

Aber, interessant mal zu sehen, wie Andere ihren Code formatieren.

Darum geht es, deshalb finde ich solche Threads niemals müßig.

[jaenicke]

Für mich sind bei der Formatierung wichtig:

• Zwingend per Codeformatter machbar (nur manuell formatieren können ist Blödsinn, das dauert viel zu lange, wenn ich fremden Quelltext einpflegen muss usw.)
• Weite Verbreitung der Formatierung, keine Sonderlocken
• Natürliches Schreiben: keine tausend unnötige Leerzeichen oder ähnliches
• Ein Befehl pro Zeile (damit man nicht erst die ganze Zeile durchlesen muss um weiterzulesen)
• Pro logischer Ebene eine Einrückung um zwei Zeichen nach rechts
• Kein Plenken

Das macht die Standardformatierung bereits, deshalb gibt es für mich keinen Grund eine andere zu benutzen. Zumal dies die häufigste Formatierung ist, wenn man so Open Source usw. anschaut. Alles andere ist eher selten bis exotisch zu finden.

Wegen des begin in einer Zeile:
Ich empfinde es als unsauber, wenn mehrere Befehle in eine Zeile gequetscht werden. Da läuft man nur in Gefahr etwas zu überlesen.

[Lemmy]

Zitat von jaenicke:

Wegen des begin in einer Zeile:
Ich empfinde es als unsauber, wenn mehrere Befehle in eine Zeile gequetscht werden. Da läuft man nur in Gefahr etwas zu überlesen.

Grundsätzlich sehe ich das wie Du: Wenn die IDE eine Formatierung als Standard verwendet mit der ich klar komme - warum ändern.. da bin ich viel zu faul dafür


Ich habe aber einige Jahre das Begin hinter die if-Verzweigung gesetzt (natürlich auch bei anderen Anweisungen), musste aber feststellen, dass diese Konstellation div. Probleme verursacht, wenn bei der Wartung nicht aufgepasst wird (d.h. das sind Fehler die vermutlich mir, aber auch anderen Entwicklern im Team passiert sind):

Anweisungen stehen im Block (eingerückt), aber das Begin-End fehlt - d.h. nur die erste Anweisung nach if wurde ausgeführt, die anderen immer
Anweisungen stehen nicht im Block (eingerückt) aber mit Begin-end (sollten also nicht im Then-Zweig stehen, tun sie aber)

...

All das hat mich dazu bewogen, das begin und end konsequent zu schreiben, auch bei nur einer Anweisung - auch um das Hirn bei der "Mustererkennung" zu entlasten

[-=ZGD=-]

Zitat von Lemmy:

All das hat mich dazu bewogen, das begin und end konsequent zu schreiben, auch bei nur einer Anweisung - auch um das Hirn bei der "Mustererkennung" zu entlasten

Sehe ich genauso. Hierbei geht es weniger um Faulheit, als um Wartbarkeit. Begin-End müssen einfach sein.

[Mavarik]

Zitat von Lemmy:

um das Hirn bei der "Mustererkennung" zu entlasten

Das ist für mich der absolut wichtigste Punkt...

Eine Code-Zeile wir i.d.R.

1x geschrieben
10x gelesen

Also ist ganz klar, ich muss mich entlasten...
Das geht natürlich über die Formatierung hinaus... Dafür braucht es Regeln (Ganz alleine für mich)

Argumente haben ein A-davor...

Also

Delphi-Quellcode:

Procedure (Const AValue : String);
begin
end;

Setter haben immer eine AValue egal von welchen typen.
Array Getter und Setter haben immer INDEX <- auch in Capslock geschrieben damit es auffällt.

Type immer ein T
Interfaces immer ein I
Lokale Variablen immer ein L... (Außer unsere geliebte For-Schleifen-Variable (i) )
Früher hatten Records immer ein Typ dahinter Datum : DatumsTyp; Zeit : ZeitTyp; (Aus UCSD-Pascal Zeiten)

Bei einer Zeile

Wert := Werte;

Was ist da Werte?

Wert := Werte(); // Klar
Wert := IWerte; // Klar;
Wert := AValue; // Auch klar

Generische Parameter heißen Arg1 Arg2 Arg3
Generische Record Bestandteile heißen Item1, Item2, Item3
Generische Typen heißen <T> oder es wird die Funktionalität bezeichnet <TResult>, <TArg>, <TSource>, <TDestination>

usw...

vor und nach einem " := " kommt eine Leertaste
Das letzte end; <- hat auch ein ";" auch wenn es nicht gebraucht wird.

Von Oliver übernommen

"( Parameter : Integer )" vor und nach den () von Parametern eine Leertaste.
"{}" Als Augenpunkt: Hier geht es weiter und damit der Autoformatter die Zeile nicht ändert.


Dann noch die praktischen Sachen..

Delphi-Quellcode:

Uses
  System.SysUtils
  ,Unit1
  ,Unit2
  ;

Einfacher um mal eben eine Unit mit // aus zu schalten...

Ich könnte noch ewig so weiter machen - stelle ich gerade fest...

Mavarik

[madas]

Zitat von jaenicke:

Für mich sind bei der Formatierung wichtig:

• Zwingend per Codeformatter machbar (nur manuell formatieren können ist Blödsinn, das dauert viel zu lange, wenn ich fremden Quelltext einpflegen muss usw.)
• Weite Verbreitung der Formatierung, keine Sonderlocken
• Natürliches Schreiben: keine tausend unnötige Leerzeichen oder ähnliches
• Ein Befehl pro Zeile (damit man nicht erst die ganze Zeile durchlesen muss um weiterzulesen)
• Pro logischer Ebene eine Einrückung um zwei Zeichen nach rechts
• Kein Plenken

Das macht die Standardformatierung bereits, deshalb gibt es für mich keinen Grund eine andere zu benutzen. Zumal dies die häufigste Formatierung ist, wenn man so Open Source usw. anschaut. Alles andere ist eher selten bis exotisch zu finden.

Wegen des begin in einer Zeile:
Ich empfinde es als unsauber, wenn mehrere Befehle in eine Zeile gequetscht werden. Da läuft man nur in Gefahr etwas zu überlesen.

Sehe ich auch so.

Delphi-Quellcode:

if (Bedingung) then
  Anweisung;

if (Bedingung) then
begin
  Anweisung;
end;

if (Bedingung) then
begin
  Anweisung1;
end else
begin
  Anweisung2;
end;

if (Bedingung1) then
begin
  Anweisung1;
end else
if (Bedingung2) then
begin
  Anweisung2;
end;

Delphi-Quellcode:

procedure NamenSindGanzWichtig;
begin
  Anweisung;
end;

procedure NamenSindGanzWichtig;
var
  blaBla: String;
begin
  Anweisung;
end;

usw. usw.

[bernau]

Mal ne andere Sache.

Seit in Delphi vermehrt Unit-Scopenames verwendet werden, wird die Units-Deklaration immer größer.

Früher sah es so aus:

Delphi-Quellcode:

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Dateedit, Buttons, ExtCtrls;

Jetzt sieht es so aus:

Delphi-Quellcode:

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, Vcl.Graphics, Vcl.Forms, Vcl.Dialogs,
  Vcl.StdCtrls, Vcl.Controls, Vcl.Buttons, Vcl.ExtCtrls, System.Classes,

Vorher schon unübersichtlich. Jetzt ganz unübersichtlich.

Stelle jetzt meine Units auf folgende Schreibweise um.

Delphi-Quellcode:

uses
  Winapi.Windows, 
  Winapi.Messages, 
  System.SysUtils, 
  System.Classes,
  Vcl.Graphics, 
  Vcl.Forms, 
  Vcl.Dialogs,
  Vcl.StdCtrls, 
  Vcl.Controls, 
  Vcl.Buttons, 
  Vcl.ExtCtrls;

Sinnvoll oder nicht?

Wie handhabt Ihr das?