Einrücken ::: ::: Wie rückt ihr ein?

[SirThornberry]

Zitat:

Zitat von MaBuSE

Zitat:

Zitat von SirThornberry

@Mabuse: mit Suchen->Ersetzen ging es auch recht schnell.

Ah, ein [Ctrl+Q][A] Fan :mrgreen:

Naja, hat den Vorteil gehabt das auch hier

Delphi-Quellcode:

  SEErdeDef.Value         := lItem.Ch_ZauberDifsDef.Erde;

vor dem ":=" die leerzeischen ersetzt werden.

[Balu der Bär]

Zitat:

Zitat von Matze

@Balu: Das Einrücken um 1 Zeichen habe ich jetzt noch nie gesehen, finde es auch etwas unübersichtlich, aber da gehen die Meinungen natürlich auseinander. ;)

Hm keine Ahnung, liegt vielleicht daran das meine VM nur ne Auflösung von 800x600 hat, da ist die Zeile schnell voll und man muss sparen wo man kann. ;) :mrgreen:

[Phoenix]

In der VM Tab-Weite = 1, ausserhalb der VM Tabweite = persönliche Vorliebe und schon ist das Platzproblem sekundär :)

[Balu der Bär]

Zitat:

Zitat von Phoenix

In der VM Tab-Weite = 1, ausserhalb der VM Tabweite = persönliche Vorliebe und schon ist das Platzproblem sekundär :)

Wenn ich es größer haben wollte, würde ich es tun, ich will es aber nicht. ;)

[rayman]

Delphi-Quellcode:

function foo: Integer;
begin
  if a > b then begin
    for i:= 0 to b do begin
      a:= 0;
      end;
    end;
  end;

Prinzip: begin ist wie eine Anweisung nur das diese in den Zeilen darunter eben erst noch definiert werden muss. Der code dafür wird (um zwei Leerzeichen) eingerückt. auch das shließende end ist mit eingerückt.

Ich persönlich finde es so am übersichtlichsten. Mir ist klar, dass ich da der Einzige bin ...
Hab auch immer Probleme mit fremdem Code und andere haben Probleme mit meinem Code. naja :mrgreen:

[Neutral General]

Delphi-Quellcode:

function foo: Integer;
begin
  if a > b then
  begin
    for i:= 0 to b do
    begin
      a:= 0;
    end;
  end;
end;

So mach ichs mittlerweile :)
Früher hab ich alles so PI*Daume gemacht :mrgreen:

Gruß
Neutral General

[inherited]

Genau so mach ichesauch. Ist meiner meinung nach auch das übersichtlichste

[semo]

ich schließe mich dem auch an.

[Cronen]

Also ich habe mich jetzt nach allerlei eigenen "Richtlinien" auf die Vorgaben vom
JEDI Code-Formater eingestellt.
Kann mir jemand sagen wie weit der vom Borland StyleGuide abweicht ?
Ich hab in der Hilfe dazu nichts gefunden.

[Sunlight7]

Meine Schreibweise:

Delphi-Quellcode:

function Foo(a, b, c, d:Integer):Integer;
   var x, y:Integer;
begin
   If a>b then // 1. If groß
      if a * b>c+d then begin // Verschachtelte ifs klein
         For x:=0 to Width-1 do // Das gleiche mit For
            for y:=0 to Height-1 do begin
               Inc(a, 1);
               Dec(b, 1);
            end;
      end;
end;

[Flare]

Ich finde auch die Version von Neutral General am Besten...also die verwende ich auch und werde die auch weiterhin verwenden, da mich bis jetzt keine andere Gesehene hier überzeugt hat.


Flare

[Balu der Bär]

Zitat:

Zitat von Sunlight7

Meine Schreibweise:

Delphi-Quellcode:

      if a * b>c+d then begin

Ist es beabsichtigt das du mal Leerzeichen zwischen den Operatoren lässt und mal nicht? :gruebel: Das sieht erst komisch aus. :P

[ErazerZ]

Zitat:

Zitat von Sunlight7

Meine Schreibweise:

Delphi-Quellcode:

function Foo(a, b, c, d:Integer):Integer;
   var x, y:Integer;
begin
   If a>b then // 1. If groß
      if a * b>c+d then begin // Verschachtelte ifs klein
         For x:=0 to Width-1 do // Das gleiche mit For
            for y:=0 to Height-1 do begin
               Inc(a, 1);
               Dec(b, 1);
            end;
      end;
end;

Um Gottes Willen wie kennst du dich bei deinem Apfelwürmchen Quellcode noch aus? :o
Ich würde das eher so machen

Delphi-Quellcode:

function Foo(a, b, c, d: Integer): Integer;
var
  x, y: Integer;
begin
  if (a > b) then
  begin
    if ((a*b) > (c+d)) then
    begin
      for x := 0 to Width -1 do
      begin
        for y := 0 to Height -1 do
        begin
          Inc(a);
          Dec(b);
        end;
      end;
    end;
  end;
end;

[Sunlight7]

@Balu, ja, das ist beabsichtigt:

Delphi-Quellcode:

1+1=1-1=1 * 1=1 / 1

Damit tue ich mir leichter, wenn man Klammern setzen muß :P :???:

Den Borland StyleGuide hab ich schon lange aufgegeben, da mir der zu unübersichtlich ist, u.a. weil er zu viele Zeilen sinnlos verbraucht.

Kleine Sachen wie

Delphi-Quellcode:

If i=0 then Exit;

schreibe ich in eine Zeile, um weiteren Platz zu sparen.

Auch nutze ich Groß/kleinschreibung:

Delphi-Quellcode:

Goto Irgendwohin;

If Mehrerebedingingerfuellt then 
   goto Irgendwohin else
      Exit;

@ErazerZ:
Genau aus dem Grund, wie Du es "Übersetzt" hast, mache ich es nicht :-D
Das kann ich nur mit viel mühe lesen :shock: :roteyes:

Die Apfelwürmchen haben jetzt über 21000 Zeilen, mit Deiner Übersetzung wären es weit über 33000 Zeilen
Viel zu unübersichtlich.

In den TPaintedButtons kannst Du meinen StyleGuide in voller Bracht bewundern. :mrgreen:

[xaromz]

Hallo,

Zitat:

Zitat von Sunlight7

Den Borland StyleGuide hab ich schon lange aufgegeben, da mir der zu unübersichtlich ist, u.a. weil er zu viele Zeilen sinnlos verbraucht.

na ja, die Zeilenanzahl ist doch kein Indiz für Übersichtlichkeit.

Zitat:

Zitat von Sunlight7

Kleine Sachen wie

Delphi-Quellcode:

If i=0 then Exit;

schreibe ich in eine Zeile, um weiteren Platz zu sparen.

Das kann man machen. Mach ich aber nicht :mrgreen: .

Zitat:

Zitat von Sunlight7

Auch nutzte ich Groß/kleinschreibung

Das habe ich mit schon lange angewöhnt (wir schreiben ja quasi Englisch).

Grundsätzlich würde ich aber so einen Styleguide nicht überbewerten. Ich bevorzuge zwar den "offiziellen", aber ich kann auch den anderen Käse lesen. Aber dass Blöcke in einer Ebene eingerückt werden halte ich für eine sinnvolle Regel, insbesondere, da das BDS (ohne Hilfsprogramme) immer noch kein Highlighting für sowas mitbringt.

Gruß
xaromz

[dino]

also wenn ich for i := 1 to 10 do mit paar sachen dahinter habe, mache ich

Delphi-Quellcode:

if a>b then
   for i:=1 to 10 do
      dosomething;
   ///
///

[malo]

meine Einrückungen:

Delphi-Quellcode:

procedure Bla;
var i: integer;
begin
if i < 5 then
begin
  i := i*2;
end
else
begin
  i := i-1;
  if i = 555 then
    ShowMessage('Das ist meine Einrückung');
  else
    ShowMessage('i <> 555');
end;
end;

Ich nutze Leerzeichen, weil ich das immer mache :P
Ist schon Gewohnheit überall mit Leerzeichen einzurücken, und ich sehe keinen besonderen Sinn darin das zu ändern ;)

[Sunlight7]

Edit: @xaromz

Okay, ohne Block einrücken... :shock:
Das kann man ja gar net mehr lesen.


Anfangs habe ich meinen Stiel öfters geändert, aber bei dem jetzigem bin ich schon paar Jahre.

Und mit Übersichtlicher meine ich, wenn man weniger Zeilen braucht, hat mein bei großen Programmblöcken mehr Übersicht, weil man einfach mehr Quelltext im sichtbaren Bereich hat, und weniger Scrollen muß.

Zitat:

Zitat von dino

Delphi-Quellcode:

if a>b then
   for i:=1 to 10 do
      dosomething;
   ///
///

Könnte fast ein Schüler von mir sein :mrgreen:
Nur, das ich das 1. If immer groß schreibe (quasi ein Satzanfang)

@malo, Ich rücke immer mit Leerzeichen ein, das bin ich noch von GWBasic & QBasic gewöhnt.

Edit: Fix, diese fehlenden roten Kasten :roll:

PS: Ist das nicht ein K&T Thema? :gruebel:

[MaBuSE]

Mich wundert es, dass noch niemand gepostet hat er würde Blocksatz bevorzugen. ;-)

Delphi-Quellcode:

function Foo(a, b, c, d:Integer):Integer; var x, y:Integer; begin If a>b then 
{1. If groß} if a * b > c+d then begin {Verschachtelte ifs klein} For x:=0 to 
Width-1 do {Das gleiche mit For} for y:=0 to Height-1 do begin Inc(a, 1); Dec
(b, 1); end; end; end;

Eigentlich ist es egal wie der Code formatiert ist. Es gibt ja schließlich genügend Programme, die den Code automatisch "richtig" formatieren. Über die Parameter kann man das Ergebnis in der Regel nach seinen Wünschen anpassen ;-)
z.B.

• DelFor: http://www.dow.wau.nl/aew/DelForExp.html
• JEDI Code Format: http://jedicodeformat.sourceforge.net/

Zum Thema Coding Standards habe ich im Thread Bt=Button, Lb=Label, Ed=Edit schon mal was geschrieben.
Ich zitiere mich mal schnell selbst ;-)

[equote="MaBuSE schrieb in http://www.delphipraxis.net/internal...=613634#613634 "]Es gibt keine Norm in dem Sinne, aber es gibt mehrere verschiedene Empfehlungen, wie Quelltext zu formatieren ist.
Dabei gibt es durchaus unterschiedliche Meinungen, wie der formatierte Quelltext auszusehen hat.
Das wichtigste ist aber, dass man sich in einem Team auf einen Standard einigt und diesen dann auch konsequent einhält. Das kann man durch verschiedene Tools unterstützen.

Hier eine Liste von verschiedenen Coding Standards:

• Borland empfiehlt folgende Formatierungsregeln:
  http://community.borland.com/article...,10280,00.html
  Der Punkt 3 "naming conventions" schweigt sich aber über Deine Frage aus ;-)
  
• Deutsche Übersetzung der Borland Style Guides
  http://www.dsdt.info/grundlagen/styleguide/
  Unsere Freunde von dsdt.info haben sich die Mühe gemacht und dem Text ins deutsche Übersetzt.
  Damit gibt es nun keine Ausreden mehr sich nicht an die Richtlinien zu halten :mrgreen:
  
• Delphi 4 Developer's Guide Coding Standards Document
  von Econos - Stefan Hoffmeister (1998)
  basiert auf dem Coding standard von Xavier Pacheco and Steve Teixeira
  http://www.econos.de/delphi/cs.html
  Hier gibt es auch eine Liste mit Präfixen zu den einzelnen Komponenten
  
• Delphi Object Pascal Coding and Project Organization Standard
  von Michael P. Hollis and Mark S. Lauter
  http://onelauter.com/codestandards/
  Hier wird zwar auch nicht auf die Präfixe eingegangen, aber es wird unter anderem auch eine Verzeichnisstruktur vorgeschlagen.
  Solch ein Dokument mit den einzuhaltenden Regeln sollte in jedem Projekt / Team existieren.
  
• Delphi coding Standards
  Maintained by Mustafa GÖKMEN
  http://gokmen.selcuk.edu.tr/document.../delphi/cs.php
  Hier ist auch eine Liste mit Präfixen enthalten
  
• Delphi Identifier Naming Conventions
  von Zarko Gajic
  http://delphi.about.com/od/standards/l/bldnc.htm
  Dieser Artikel befasst sich nur mit der Benamung von Variablen

Diese Liste sollte dir erst mal einen Überblick ermöglichen.

Da es keine Norm gibt, sondern nur Empfehlungen such Dir eine aus, komplettiere sie um die Projekt / Team spezifischen Informationen und versuch sie dann auch einzuhalten.
Ich persönlich mag eine Mischung aus dem Text von Borland und dem von Econos ergänzt um einige kleine Änderungen von mir.

Viel Spaß beim Lesen.[/equote]

[Sidorion]

Das:

Zitat:

Zitat von dino

also wenn ich for i := 1 to 10 do mit paar sachen dahinter habe, mache ich

Delphi-Quellcode:

if a>b then
   for i:=1 to 10 do
      dosomething;
   ///
///

ist wohl das gefährlichste, was man machen kann. Wenn schon kein Begin, dann wenigstens das Then mit in die neue Zeile nehmen,also entweder so:

Delphi-Quellcode:

If Foo Then Bar;

oder so:

Delphi-Quellcode:

If Foo
Then Bar

Weil: in solchen Konstrukten kann es leicht passieren, dass wenn man mal ne Programmzeile hinter das If schreiben will die Bedingte Anweisung nach dem If durch die neue erstetzt und dann ist der Code futsch. Auch sollte man bei mehrzeiligen Anweisungen (wie z.b.: For) unbedingt einen Block nehmen (Begin..End) um zu zeigen, dass ALLE Zeilen zu dieser Anweisung gehören, also etwa so:

Delphi-Quellcode:

if a>b then begin
  for i:=1 to 10 do begin
    dosomething;
  end;
end;

Dann sieht man auch besser, wann die Anweisung zuende ist.

[Sunlight7]

Zitat:

Zitat von Sidorion

ist wohl das gefährlichste, was man machen kann. Wenn schon kein Begin, dann wenigstens das Then mit in die neue Zeile nehmen,...

:shock: :shock: :shock:
Also ich schreib schon seit JAHREN so, was gefährliches hab ich daran noch nicht entdecken können :mrgreen:

Delphi-Quellcode:

Weil: in solchen Konstrukten kann es leicht passieren, dass wenn man mal ne Programmzeile hinter das If schreiben will die Bedingte Anweisung nach dem If durch die neue erstetzt und dann ist der Code futsch. Auch sollte man bei mehrzeiligen Anweisungen (wie z.b.: For) unbedingt einen Block nehmen (Begin..End) um zu zeigen, dass ALLE Zeilen zu dieser Anweisung gehören, also etwa so:

Warum sollte dann der Code "futsch" sein :gruebel: :gruebel: :gruebel:
Und auf Überflüssige begin..end Blöcke verzichte ich sowieso :???:

@MaBuSE: Da stimme ich Dir zu, genau wie in dem anderem Thread, eigentlich ist es völlig egal, wie man es schreibt, jedoch halt so, das man es am bestem lesen kann.
Ausnahme ist eben, wenn eine Gruppe zusammen arbeitet, dann sollte man sich auf etwas einigen.

[Cöster]

Zitat:

Zitat von Sunlight7

@Balu, ja, das ist beabsichtigt:

Delphi-Quellcode:

1+1=1-1=1 * 1=1 / 1

Damit tue ich mir leichter, wenn man Klammern setzen muß :P :???:

Ich hab's mal ne Zeit lang so gemacht, dass ich bei Punktrechnung keine Leerzeichen gelassen hab, bei Strichrechnung aber schon, weil Punktrechnung vor Strichrechnung geht und deswegen imho enger zusammen gehört. Aber inzwischen benutze ich in beiden Fällen Leerzeichen.

Wie macht ihr das, wenn eine Zeile zu lang ist (über 80 Zeichen)?
Ich kann mich da oft nicht entscheiden. Wenn alles hinter dem ':=' alleine in eine Zeile passt, drück ich nach dem ':=' auch gerne mal die Enter-Taste.
Oder bei langen Parameterlisten? Alles innerhalb der Klammer in eine Zeile (wenn's passt) oder Teile direkt hinter die geöffnete Klammer und den Rest in die nächste Zeile?
Was macht ihr, wenn nach einem until mehrere Bedingungen kommen, die nicht in eine Zeile passen? Soviel wie passt in die erste Zeile und den Rest dadrunter 2 Zeilen eingerückt? Oder den Rest darunter auf höhe der Bedingung in der ersten Zeile?

Zitat:

Zitat von MaBuSE

Mich wundert es, dass noch niemand gepostet hat er würde Blocksatz bevorzugen. ;-)

Delphi-Quellcode:

function Foo(a, b, c, d:Integer):Integer; var x, y:Integer; begin If a>b then 
{1. If groß} if a * b > c+d then begin {Verschachtelte ifs klein} For x:=0 to 
Width-1 do {Das gleiche mit For} for y:=0 to Height-1 do begin Inc(a, 1); Dec
(b, 1); end; end; end;

Das fällt dann schon fast in die Kathegorie Verschlüsselung^^

[Namenloser]

Zitat:

Zitat von Cöster

Ich hab's mal ne Zeit lang so gemacht, dass ich bei Punktrechnung keine Leerzeichen gelassen hab, bei Strichrechnung aber schon, weil Punktrechnung vor Strichrechnung geht und deswegen imho enger zusammen gehört.

Hattest du zufällig mal eine gewisse Frau Schuster in Mathe :stupid:

Also ich mach auch zwischen den Rechenzeichen leerzeichen, weil ich das übersichtlicher finde.
Probleme hab ich, wenn man umbrechen müsste, aber die Zeile selbst mit Umbruch noch zu lang ist. Wie macht ihr das?

Delphi-Quellcode:

function Foo(a, b, c, d:Integer):Integer; var x, y:Integer; begin If a>b then
{1. If groß} if a * b > c+d then begin {Verschachtelte ifs klein} For x:=0 to
Width-1 do {Das gleiche mit For} for y:=0 to Height-1 do begin Inc(a, 1); Dec
(b, 1); end; end; end;

Das ist natürlich das nonplusultra :wink:

[Cöster]

Zitat:

Zitat von NamenLozer

Hattest du zufällig mal eine gewisse Frau Schuster in Mathe :stupid:

Nein. Gibt wohl noch andere, die das so sehen wie ich es sah.

Zitat:

Zitat von NamenLozer

Probleme hab ich, wenn man umbrechen müsste, aber die Zeile selbst mit Umbruch noch zu lang ist. Wie macht ihr das?

Ich lass den Operator dann am Ende der Zeile stehen und breche danach um.

[Sunlight7]

Zitat:

Zitat von Cöster

Wie macht ihr das, wenn eine Zeile zu lang ist (über 80 Zeichen)?

Warum 80 Zeichen, es sind doch 255 möglich :zwinker:

Und wenn ich die 255 erreiche breche ich das bei der nähersten Gelegenheit um und rücke in der nächsten Zeile ein.

[Cöster]

Zitat:

Zitat von Sunlight7

Zitat:

Zitat von Cöster

Wie macht ihr das, wenn eine Zeile zu lang ist (über 80 Zeichen)?

Warum 80 Zeichen, es sind doch 255 möglich :zwinker:

Also mir persönlich gefällt's immer am besten, wenn ich meinen Code auch noch sehen kann. Aber das muss ich auch mal ausprobieren, und zusätzlich noch Blocksatz natürlich. So spart man bestimmt 90% Zeilen :-D

[Prototypjack]

Moin,
Grundsätzlich halte ich mich an den Borland Styleguide.
Jedoch mache ich gewisse Dinge ein bisschen anders (Aber auch Styleguide-Legitim).
Wie zum Beispiel verwende ich IMMER wo ein Begin-Block möglich ist, selbigen.

Delphi-Quellcode:

procedure ButtonClick(Sender: Tbject);
begin
  if A < B then
  begin
    Label1.Caption := 'Foo';
  end;
  for I := 0 to SomeList.Count - 1 do
  begin
    if I > A then
    begin
      Label1.Caption := 'Bar';
    end;
  end;
end;

[Sidorion]

@Sunlight7
Das gefährliche daran ist wenn Du im Team arbeitest und z.B.: der Kunde anruft, bei ihm geht nix mehr und Du im Urlaub bist. Dann muss Dein Kollege Deinen Code korrigieren und z.B.: nochne Zeile einfügen muss.
Ein Beispiel:

Delphi-Quellcode:

If Bedingung Then
  TuWas;

Jetzt stellt Dein Kollege fest, vor TuWas muss TuNochwas und fügt TuNochwas ein, dann sieht der Code so aus:

Delphi-Quellcode:

If Bedingung Then
  TuNochwas;
  TuWas;

Jetzt wird nurnoch TuNochwas bedingt ausgeführt und TuWas immer.
Wenn das Then mit unten steht kann das nicht passieren, weil klar ersichtlich ist, dass TuWas zur If-Abfrage gehört.
In so einem einfachen Beispiel wird die Notwendigkeit jetzt nur bedingt deutlich, aber lass mal Bedingung sich über die ganze Zeile erstrecken, dann sieht man das Then nicht auf den ersten Blick.
Auf Einrückungen kann man sich nicht vorbehaltslos verlassen, da die IDE es durchaus schafft manchmal die Einrückungen zu verändern (hab ich mehrfach schon erlebt).

[Sunlight7]

Wie gut, das ich nur alleine und Privat programmiere :???:
Da brauch ich mich nicht um Kollegen kümmern :angel2:

[Tyrael Y.]

Zitat:

Zitat von Prototypjack

Delphi-Quellcode:

procedure ButtonClick(Sender: TObject);
begin
  if A < B then
  begin
    Label1.Caption := 'Foo';
  end;
  for I := 0 to SomeList.Count - 1 do
  begin
    if I > A then
    begin
      Label1.Caption := 'Bar';
    end;
  end;
end;

Genauso sieht bei mir auch der Code aus.
Bin halt konsequent in setzen von begin end.
Bei Erweiterungen des Codes kann man sich auch nicht vertun bzw. etwas übersehen.

[xZise]

Also ich rücke immer so ein:

Delphi-Quellcode:

procedure SetVar(myVar : Integer);
var
  i : Integer;
begin
  if myVar > 255 then
    for i := 256 to myVar do begin
      inc(myVar, myVar * i);
    end;
end;

[Meflin]

Zitat:

Wie macht ihr das, wenn eine Zeile zu lang ist (über 80 Zeichen)?

Also bei langen Parameterlisten (in Funktionsaufrufen) bevorzuge ich diese Formatierung:

Delphi-Quellcode:

Result := FooWithExtraUltraLongParamList(
  Param1,
  Param2,
  Param3,
  ...
  Paramn
);

Kann man dann auch besser kommentieren ;)

Bei Funktionsdeklarationen schreib ichs aber nebeneinander und wenn die Zeile zu Ende ist eben in die neue.

[Tormentor32]

Also ich machs immer so:

Delphi-Quellcode:

begin
  if a = b
    then
      begin
      end
    else
  if x = y
    then
      for c := d to e do
        begin
        end
    else
      begin
      end
end;

Ich finds so sehr übersichtlich, aber jedem das seine...

edit: Und ich benutze Tab :wink:

[Hador]

Zitat:

Zitat von Tormentor32

Delphi-Quellcode:

begin
  if a = b
    then
      begin
      end
    else
  if x = y
    then
      for c := d to e do
        begin
        end
    else
      begin
      end
end;

Das finde ich persönlich völlig unübersichtlich.
Zugegeben in diesem Beispiel ist es nich ok - aber wenn man sich vorstellt, dass sagen wir mal 3 if-Statements und 2 Schleifen ineinander verschachtelt wären, würde das ganze riesig werden.

Ich halte mich - bis auf eine Außnahme - an den Borland Styleguide:

Delphi-Quellcode:

procedure Foo;
var
  F: TFoo;
begin
  if <Bedingung> then 
    Tuwas;

  if <Bedingung> then 
  begin
    Tuwas;
    TuNochwas;
  end;

  if <Bedingung> then 
  begin
    Tuwas;
    TuNochwas;
  end else begin  // Die Abweichung vom Styleguide
    Tuwas;
    TuNochwas;
  end;

  for i:=0 to 100 do
    Tuwas;

  for i:=0 to 100 do
  begin
    Tuwas;
    TuNochwas;
  end;

  //Und so weiter
end;

[xZise]

@ Paramter: Ich schreibe sie generell in eine Zeile :D

[Cöster]

Zitat:

Zitat von xZise

@ Paramter: Ich schreibe sie generell in eine Zeile :D

Ich find Melfins Variante ganz gut, werd ich mal ausprobieren. Wenn jeder Parameter eine längere Rechnung beinhaltet, wäre es imho recht unübersichtlich, daraus eine 200 Zeichen lange Zeile zu machen. A la Melfin könnte man dagegen sofort erkennen, wie sich die einzelnen Params ergeben.

[blablab]

Ich rücke so ein:

Delphi-Quellcode:

// FALSCH
  if A < B then begin
    DoSomething;
    DoSomethingElse;
  end else begin
    DoThis;
    DoThat;
  end;

Meiner Meinung nach ist das noch am besten lesbar und am Platzsparensten.
Was bringts mir wenn ich 3 Zeilen hab mit

Delphi-Quellcode:

end
else
begin

als ob das besser lesbar wäre...

Naja, kann man nix machen, es ist ja FALSCH!!!

[Hansa]

Vergleicht mal das hier (so würd ich es schreiben) :

Zitat:

Zitat von Tormentor32

Also ich machs immer so:

Delphi-Quellcode:

begin
  if a = b then begin
  end
  else if x = y then
    for c := d to e do begin
    end
  else begin
  end;
end;

mit dem Original hier :

Zitat:

Zitat von Tormentor32

Also ich machs immer so:

Delphi-Quellcode:

begin
  if a = b
    then
      begin
      end
    else
  if x = y
    then
      for c := d to e do
        begin
        end
    else
      begin
      end
end;

Macht IMHO lediglich Sinn, wenn einer nach Anzahl der Quelltextzeilen bezahlt werden will und das Papier/21" Monitor geschenkt kriegt. :mrgreen:

Edit : Einrückung war zuerst auch verkehrt. :mrgreen:

[Melfin]

Zitat:

Zitat von Cöster

Ich find Melfins Variante ganz gut, werd ich mal ausprobieren.

Das war zwar garnicht meine :oops: aber ich finde sie eigentlich auch gan gut :mrgreen:

Zitat:

als ob das besser lesbar wäre...
Naja, kann man nix machen, es ist ja FALSCH!!!

Wenns für dich richtig ist, kann es doch nicht falsch sein ;)

[Luckie]

Gerade fertig geworden: MpuAboutWnd.pas

Schönes Beispiel von mir, wie ich meinen Code formatiere, Variablen benennen und für meinen Styl insgesamt.