Hallo,

Welche Schreibweise würdet Ihr vorziehen und warum? (Oder wann welche?)

var Foo = {};

Foo.bar = function () {return "bar";};
Foo.baz = function () {return "baz";};

>   
> oder  
>   
> ~~~javascript

var Foo =  

> {  
>   bar: function () {return "bar";},  
>   baz: function () {return "baz";}  
> };

So generell kann ich das nicht sagen. Eigentlich ist mir die zweite Variante lieber, mit kleiner Abwandlung:

var Foo = {

bar: function () {return "bar";},
  baz: function () {return "baz";}
};

  
Das hat den Vorteil, dass man gleich sieht, was zusammengehört.  
  
Allerdings bei umfangreicheren Objekten und tieferen Verschachtelungen hat das den Nachteil, dass man mehr Einrückungen braucht, was die Übersicht wieder erschwert.  
  
Gruß, Don P  

Hellihello Gunnar,

var Foo =

{
  bar: function () {return "bar";},

baz: function () {return "baz";}
};

  
Allman-Style was die geschweiften Klammern angeht, oder? Vorteil: sieht bei Code-Folding "gut" aus. Immerhin kann man bei PHP mehrer Klassen mit Codefolding ganz gut in einem Dokument übersichtlich verarbeiten und hat die Klassenüberschrift immer noch sichtbar. Zumindest macht der Scite das so.  
  
Dank und Gruß,  
  
frankx

Hallo,

Ich finde die ausführlichere Schreibweise für längere Sachen geeigneter. Der Logik nach kommt nach dem öffnenden »{« beim Object-Literal eine Einrückungsebene, sodass der gesamte Code im Literal schonmal um eine Ebene eingerückt wird. Je nachdem, wie kompliziert die Funktionen sind, hängt der letztliche Code durch sowas extrem weit rechts. Mit der langen Schreibweise hängt der Code in den Funktionen dann eine Stufe weiter links.

Die Wiederaufnahme des Schemas Bla.bezeichner = function () { ... }; ist auch ohne den Kontext des möglicherweise riesigen Object-Literals verständlich. Wenn ich also an einer beliebigen Stelle in den Quellcode schaue, brauche ich nicht viele Seiten nach oben scrollen, um dort irgendwo ein unauffälliges »var bla = {« zu finden. (Das stört mich bei Prototype, jQuery und Co. sehr.)

Nicht zuletzt kann man die Zuweisungen von Bla.a und Bla.b trennen. Bla = { /* und hier alles drin */ } ist immer die Erstdefinition, die vorige Member überschreibt. Mit dem Schema Bla.member = ... kann man immer anhängen, anstatt monolithisch zu definieren. Davor kann man dann ggf. if (!window.Bla) Bla = {}; hängen, wenn man sowas wie optionale Module realisieren will.

Letztlich läuft es m.E. aber auf eine Mischung von beiden Formen hinaus. Das kann man schwer so allgemein diskutieren, denke ich. Ich verwende für kurze zusammenhängende Scripte gerne das Object-Literal. Wenns dann komplizierter wird, stören sie mich allerdings und beißen sich mit Namespacing und Modularisierung, wie ich sie gerne hätte.

Mathias