tag:forum.selfhtml.org,2005:/selfAufbau von Funktionen/Objekten. Verständnisfrage – SELFHTML-Forum2012-07-19T11:41:39Zhttps://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553133?srt=yes#m1553133Siri2012-07-19T05:51:51Z2012-07-19T05:51:51ZAufbau von Funktionen/Objekten. Verständnisfrage<p>Hallo,</p>
<p>ich hab Molilys überaus interessante <a href="http://molily.de/js/" rel="nofollow noopener noreferrer">"Einführung in JavaScript"</a> gelesen und mich damit auseinander gesetzt. Alles habe ich aber auch nach mehrmaligem lesen nicht verstanden.</p>
<p>Variante A:</p>
<pre><code class="block language-javascript"><span class="token keyword">function</span> <span class="token function">Konstruktor1</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token comment">//privat </span>
k1var1 <span class="token operator">=</span> <span class="token string">"test1"</span><span class="token punctuation">;</span>
<span class="token comment">// öffentlich </span>
<span class="token keyword">this</span><span class="token punctuation">.</span>k1var2 <span class="token operator">=</span> <span class="token string">"test2"</span><span class="token punctuation">;</span>
<span class="token comment">//privat </span>
<span class="token function-variable function">k1methode1</span> <span class="token operator">=</span> <span class="token keyword">function</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token function">alert</span> <span class="token punctuation">(</span>k1var1<span class="token operator">+</span><span class="token string">"-"</span><span class="token operator">+</span><span class="token keyword">this</span><span class="token punctuation">.</span>k1var2<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">//öffentlich </span>
<span class="token keyword">this</span><span class="token punctuation">.</span><span class="token function-variable function">k1methode2</span> <span class="token operator">=</span> <span class="token keyword">function</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token function">alert</span> <span class="token punctuation">(</span>k1var1<span class="token operator">+</span><span class="token string">"-"</span><span class="token operator">+</span><span class="token keyword">this</span><span class="token punctuation">.</span>k1var2<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token keyword">var</span> instanz1 <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Konstuktor1</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
instanz1<span class="token punctuation">.</span><span class="token function">k1methode2</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// geht </span>
instanz1<span class="token punctuation">.</span><span class="token function">k1methode1</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// geht nicht</span>
</code></pre>
<p>Variante B:</p>
<pre><code class="block language-javascript"><span class="token keyword">function</span> <span class="token function">Konstruktor2</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token comment">//privat </span>
<span class="token keyword">var</span> k2var1 <span class="token operator">=</span> <span class="token string">"test3"</span><span class="token punctuation">;</span>
<span class="token comment">// öffentlich </span>
k2var2 <span class="token operator">=</span> <span class="token string">"test4"</span><span class="token punctuation">;</span>
<span class="token comment">//privat </span>
<span class="token keyword">function</span> <span class="token function">k2methode1</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token function">alert</span> <span class="token punctuation">(</span>k2var1<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">//öffentlich </span>
<span class="token keyword">return</span> <span class="token punctuation">{</span>
<span class="token function-variable function">k2methode2</span><span class="token operator">:</span> <span class="token keyword">function</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token function">alert</span> <span class="token punctuation">(</span>k2var1<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token keyword">var</span> instanz2 <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Konstuktor2</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
instanz2<span class="token punctuation">.</span><span class="token function">k2methode2</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// geht </span>
instanz2<span class="token punctuation">.</span><span class="token function">k2methode1</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// geht nicht</span>
</code></pre>
<p>Beide Schreibweisen erlauben die Deklaration von privaten und öffentlichen Variablen/Methoden. Wo liegt der Unterschied? Ist es eine Frage des persönlichen Stils? Oder gibt es bestimmte Einsatzzwecke für die eine der Varianten besser geeignet ist als die andere?</p>
<p>Grüße<br>
Siri</p>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553137?srt=yes#m1553137molilyzapperlott@gmail.com2012-07-19T08:27:47Z2012-07-19T08:27:47ZAufbau von Funktionen/Objekten. Verständnisfrage<p>Hallo,</p>
<blockquote>
<p>Beide Schreibweisen erlauben die Deklaration von privaten und öffentlichen Variablen/Methoden. Wo liegt der Unterschied?</p>
</blockquote>
<p>Normalerweise gibt ein Konstruktor nichts explizit mit »return« zurück, denn »new Konstruktor« gibt automatisch das damit neu erzeugte Instanzobjekt zurück.</p>
<p>Ein Konstruktor *kann* ein anderes Objekt als die Instanz zurückgeben, i.d.R. besteht dazu aber kein Grund. Die zweite Variante ist daher unüblich. Wahrscheinlich verwechselst du sie mit dem Module-Pattern oder rein funktionaler Erzeugung von Objekten (letztere behandle ich in meiner Einführung nicht). Dann würde man aber nicht mit »new« arbeiten:</p>
<pre><code class="block language-javascript"><span class="token keyword">function</span> <span class="token function">createFoo</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">function</span> <span class="token function">privateFunc</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token keyword">return</span> <span class="token punctuation">{</span>
<span class="token function-variable function">func</span><span class="token operator">:</span> <span class="token keyword">function</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token function">privateFunc</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">var</span> foo <span class="token operator">=</span> <span class="token function">createFoo</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
foo<span class="token punctuation">.</span><span class="token function">func</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
<p>Manche propagieren einen solchen funktionalen Stil, weil er verschiedene Vorteile hat (siehe dazu Douglas Crockfords »JavaScript: The Good Parts«).</p>
<p>Bei einem normalen Konstruktor, der mit new aufgerufen wird, gibt es i.d.R. kein return-Statement. Man greift darin über »this« auf das bereits erzeugte Instanzobjekt zurück.</p>
<p>Mathias</p>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553134?srt=yes#m1553134peterS.pseliger@gmx.nethttp://pseliger.de/translations/Douglas-Crockford/missunderstood-JavaScript.html2012-07-19T09:33:12Z2012-07-19T09:33:12ZAufbau von Funktionen/Objekten. Verständnisfrage<p>gruss Siri,</p>
<blockquote>
<p>Beide Schreibweisen erlauben die Deklaration von privaten und öffentlichen<br>
Variablen/Methoden. Wo liegt der Unterschied? ...<br>
...</p>
</blockquote>
<p>Variante A ist eine Konstruktorfunktion, die über den [new] Operator und den<br>
den Bezug auf [this] Instanzen ihres eigenen Typs erstellt.</p>
<p><code class="language-javascript"><span class="token punctuation">(</span><span class="token keyword">new</span> <span class="token class-name">Konstruktor1</span><span class="token punctuation">)</span> <span class="token keyword">instanceof</span> <span class="token class-name">Konstruktor1</span></code> ist in jedem Fall wahr.</p>
<blockquote>
<p>...<br>
Variante A:</p>
<pre><code class="block language-javascript"></code></pre>
</blockquote>
<p>function Konstruktor1 () {</p>
<blockquote>
<p>//privat<br>
k1var1 = "test1";</p>
</blockquote>
<p>/*<br>
ganz böse ... die Zuweisung von "test1" auf [k1var1] erfolgt im globalen Namensraum.<br>
Nur ein vorangestelltes [var] zwingt [k1var1] in den lokalen Scope der Funktion [Konstruktor1].<br>
<em>/<br>
//local<br>
var k1var1 = "test1";<br>
/</em><br>
Kapselung wird durch den lokalen Scope der Variable und dem Aufruf von [Konstruktor1] erreicht.<br>
Siehe dazu molilys Erläuterungen zu [Closure]s.<br>
*/</p>
<blockquote>
<p>// öffentlich<br>
this.k1var2 = "test2";</p>
</blockquote>
<p>/*<br>
Richtig. [this] bindet die Eigenschaft [k1var2] direkt adressierbar an jede Instanz der<br>
Konstruktor-Funktion [Konstruktor1].<br>
*/</p>
<blockquote>
<p>//privat<br>
k1methode1 = function() {<br>
alert (k1var1+"-"+this.k1var2);<br>
}</p>
</blockquote>
<p>/*<br>
nein - keineswegs privat, sondern global - siehe Erklärung weiter oben und Korrektur direkt darunter.<br>
*/<br>
var k1methode1 = function() {<br>
alert (k1var1+"-"+this.k1var2);<br>
}</p>
<blockquote>
<p>//öffentlich<br>
this.k1methode2 = function() {<br>
alert (k1var1+"-"+this.k1var2);<br>
}</p>
</blockquote>
<p>/*<br>
jo.<br>
*/</p>
<blockquote>
<p>}<br>
var instanz1 = new Konstuktor1();<br>
instanz1.k1methode2(); // geht</p>
</blockquote>
<p>/*<br>
jepp<br>
*/</p>
<blockquote>
<p>instanz1.k1methode1(); // geht nicht</p>
</blockquote>
<p>/*<br>
richtig - [k1methode1] wurde ja auch im globalen Namensraum angelegt<br>
<em>/<br>
window.k1methode1();<br>
/</em><br>
... sollte aufrufbar sein und "test1-undefined" liefern ...<br>
... warum? ...</p>
<p>- [k1var1] wurde ebenfall global angelegt und lässt sich nach "test1" auflösen.<br>
- [k1var2] hingegen existiert nicht im globalen namensraum, ...<br>
- ... denn genau dorthin wird [this.k1var2] aus der global angelegten [k1methode1] aufgelöst.<br>
*/</p>
<pre><code class="block">
> ...
Die Methode [Konstruktor2] ist keine Konstruktor-Funktion, obwohl der gemeinsame Aufruf von
[new] Operator und [Konstruktor2] aus dem Beispiel der Variante B dies so erscheinen läßt.
`(new Konstruktor2) instanceof Konstruktor2`{:.language-javascript} wird niemals wahr sein.
Warum?
[Konstruktor2] gibt ein durch ein Objekt-Literal erzeugtes Objekt zurück. Dieses Objekt ist
somit keine Instanz von [Konstruktor2]. Als einzige Eigenschaft besitzt dieses Objekt die
Methode [k2methode2], die nur deshalb Zugriff auf die im lokalen Funktions-Scope von [Konstruktor2]
vereinbarte Variable [k2var1] hat, da das zurückgegebene Objekt im selben Scope erzeugt wird.
Siehe dazu wiederum molilys Erläuterungen zu [Closure]s.
> ...
> Variante B:
> ~~~javascript
function Konstruktor2 () {
>
> //privat
> var k2var1 = "test3";
/*
jepp - aber trotzdem bitte "lokal" statt "privat" denken und schreiben.
*/
> // öffentlich
> k2var2 = "test4";
/*
nope - [k2var2] liegt im globalen Namensraum - siehe Erläuterungen zu Beispiel A.
*/
>
> //privat
> function k2methode1() {
> alert (k2var1);
> }
/*
jepp
*/
> //öffentlich
> return {
> k2methode2: function() {
> alert (k2var1);
> }
> }
/*
siehe Erklärung zu Beispiel B.
*/
> }
> var instanz2 = new Konstuktor2();
> instanz2.k2methode2(); // geht
/*
aber nur wegen [link:http://molily.de/js/organisation-module.html#revealing-module@title=Revealing Module Pattern]
*/
> instanz2.k2methode1(); // geht nicht
/*
richtig - [k2methode1] wurde ja auch im globalen Namensraum angelegt
*/
> ...
</code></pre>
<blockquote>
<p>... Ist es eine Frage des persönlichen Stils? Oder gibt es bestimmte Einsatzzwecke für die eine<br>
der Varianten besser geeignet ist als die andere?</p>
</blockquote>
<p>Benutze Konstruktoren, wenn Du ein Typsystem erstellen möchtest, wo Du die Herkunft von Objekten<br>
anhand des [instanceof] Operators bestimmen möchtest. bzw. wenn Deinen Objekten Methoden über die<br>
Delegation durch [Constructor.prototype] zugewiesen werden sollen.</p>
<p>so long - peterS. - pseliger@gmx.net</p>
<div class="signature">-- <br>
»Because objects in JavaScript are so flexible, you will want to think differently about class hierarchies.<br>
Deep hierarchies are inappropriate. Shallow hierarchies are efficient and expressive.« - <a href="http://javascript.crockford.com/" rel="nofollow noopener noreferrer">Douglas Crockford</a><br>
<a href="http://www.peter.in-berlin.de/projekte/selfcode/?code=ie%3A%28+fl%3A%29+br%3A%3E+va%3A%28+ls%3A%26+fo%3A%29+rl%3A%29+n3%3B%7D+n4%3A%7D+ss%3A%7D+de%3A%B5+js%3A%7D+mo%3A%3F+zu%3A%5D" rel="nofollow noopener noreferrer">ie:( fl:) br:> va:( ls:& fo:) rl:) n3;} n4:} ss:} de:µ js:} mo:? zu:]</a>
</div>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553135?srt=yes#m1553135Siri2012-07-19T10:38:33Z2012-07-19T10:38:33ZAufbau von Funktionen/Objekten. Verständnisfrage<p>Hallo,</p>
<p>vielen Dank!</p>
<p>Schwerer Tobak... Da muss ich wohl noch mehr in die Praxis gehen, aber ich denke ich hab jetzt die Grundzüge besser verstanden.</p>
<p>Grüsse<br>
Siri</p>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553136?srt=yes#m1553136peterS.pseliger@gmx.net2012-07-19T11:41:39Z2012-07-19T11:41:39ZAufbau von Funktionen/Objekten. Verständnisfrage<p>hallo again Siri</p>
<blockquote>
<p>Schwerer Tobak... Da muss ich wohl noch mehr in die Praxis gehen, ...</p>
</blockquote>
<p>dann lass doch mal zur Veranschaulichung den folgenden auf das Minimum<br>
reduzierte Code zeilenweise auf eine JavaScript-Konsole los.</p>
<pre><code class="block language-javascript">
<span class="token keyword">var</span> <span class="token function-variable function">x</span> <span class="token operator">=</span> <span class="token keyword">function</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token keyword">var</span> a<span class="token operator">=</span><span class="token string">"a"</span><span class="token punctuation">;</span><span class="token keyword">return</span> <span class="token punctuation">{</span><span class="token literal-property property">a</span><span class="token operator">:</span>a<span class="token punctuation">}</span><span class="token punctuation">;</span><span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token comment">// undefined </span>
<span class="token function">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// Object -> a: "a" </span>
<span class="token function">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">instanceof</span> <span class="token class-name">x</span> <span class="token comment">// false </span>
<span class="token keyword">new</span> <span class="token class-name">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// Object -> a: "a" </span>
<span class="token keyword">new</span> <span class="token class-name">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">instanceof</span> <span class="token class-name">x</span> <span class="token comment">// false </span>
<span class="token keyword">var</span> <span class="token function-variable function">x</span> <span class="token operator">=</span> <span class="token keyword">function</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token keyword">var</span> a<span class="token operator">=</span><span class="token string">"a"</span><span class="token punctuation">;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>a<span class="token operator">=</span>a<span class="token punctuation">;</span><span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token comment">// undefined </span>
<span class="token function">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// undefined </span>
<span class="token function">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">instanceof</span> <span class="token class-name">x</span> <span class="token comment">// false </span>
<span class="token keyword">new</span> <span class="token class-name">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// x -> a: "a" </span>
<span class="token keyword">new</span> <span class="token class-name">x</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">instanceof</span> <span class="token class-name">x</span> <span class="token comment">// true </span>
</code></pre>
<blockquote>
<p>... aber ich denke ich hab jetzt die Grundzüge besser verstanden.</p>
</blockquote>
<p>so long - peterS. - pseliger@gmx.net</p>
<div class="signature">-- <br>
»Because objects in JavaScript are so flexible, you will want to think differently about class hierarchies.<br>
Deep hierarchies are inappropriate. Shallow hierarchies are efficient and expressive.« - <a href="http://javascript.crockford.com/" rel="nofollow noopener noreferrer">Douglas Crockford</a><br>
<a href="http://www.peter.in-berlin.de/projekte/selfcode/?code=ie%3A%28+fl%3A%29+br%3A%3E+va%3A%28+ls%3A%26+fo%3A%29+rl%3A%29+n3%3B%7D+n4%3A%7D+ss%3A%7D+de%3A%B5+js%3A%7D+mo%3A%3F+zu%3A%5D" rel="nofollow noopener noreferrer">ie:( fl:) br:> va:( ls:& fo:) rl:) n3;} n4:} ss:} de:µ js:} mo:? zu:]</a>
</div>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553138?srt=yes#m1553138Siri2012-07-19T09:23:34Z2012-07-19T09:23:34ZAufbau von Funktionen/Objekten. Verständnisfrage<p>Hallo,</p>
<p>vielen Dank für die Erläuterung!</p>
<blockquote>
<pre><code class="block language-javascript"></code></pre>
</blockquote>
<p>function createFoo () {</p>
<blockquote>
<p>function privateFunc () {}<br>
return {<br>
func: function () {<br>
privateFunc();<br>
}<br>
};<br>
}</p>
<p>var foo = createFoo();<br>
foo.func();</p>
</blockquote>
<pre><code class="block">
Könnte man also sagen, dass die obige Variante "statisch" ist?
Grüße
Siri
</code></pre>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553139?srt=yes#m1553139molilyzapperlott@gmail.comhttp://molily.de/2012-07-19T09:59:07Z2012-07-19T09:59:07ZAufbau von Funktionen/Objekten. Verständnisfrage<blockquote>
<blockquote>
<pre><code class="block language-javascript"></code></pre>
</blockquote>
</blockquote>
<p>function createFoo () {</p>
<blockquote>
<blockquote>
<p>function privateFunc () {}<br>
return {<br>
func: function () {<br>
privateFunc();<br>
}<br>
};<br>
}</p>
<p>var foo = createFoo();<br>
foo.func();</p>
</blockquote>
</blockquote>
<pre><code class="block">
>
> Könnte man also sagen, dass die obige Variante "statisch" ist?
Inwiefern statisch? Was bedeutet das? Im Gegensatz zu dynamisch?
Mathias
--
[Chaplin - An Application Architecture Using Backbone.js](https://github.com/chaplinjs/chaplin)
</code></pre>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553140?srt=yes#m1553140Siri2012-07-19T10:19:40Z2012-07-19T10:19:40ZAufbau von Funktionen/Objekten. Verständnisfrage<p>Hallo,</p>
<blockquote>
<blockquote>
<p>Könnte man also sagen, dass die obige Variante "statisch" ist?</p>
</blockquote>
<p>Inwiefern statisch? Was bedeutet das? Im Gegensatz zu dynamisch?</p>
</blockquote>
<p>Wenn man einen hinkenden Vergleich zu Java ziehen möchte. Wenn ich also die Methoden einer Klasse statisch aufrufe, ohne vorher ein Objekt erzeugt zu haben.</p>
<p>Grüße<br>
Siri</p>
https://forum.selfhtml.org/self/2012/jul/19/aufbau-von-funktionen-objekten-verstaendnisfrage/1553141?srt=yes#m1553141molilyzapperlott@gmail.comhttp://molily.de/2012-07-19T10:46:26Z2012-07-19T10:46:26ZAufbau von Funktionen/Objekten. Verständnisfrage<blockquote>
<p>Wenn man einen hinkenden Vergleich zu Java ziehen möchte. Wenn ich also die Methoden einer Klasse statisch aufrufe, ohne vorher ein Objekt erzeugt zu haben.</p>
</blockquote>
<p>Dieses Wort verwendet man in diesem Zusammenhang in JavaScript nicht. Es handelt sich um einfache Objekte mit Funktionen als Eigenschaften. Der Vergleich zu Klassen mit statischen Methoden passt da vorne und hinten nicht. Es *wird* ja ein Objekt erzeugt und eine Funktion daran gehängt.</p>
<p>Das Konzept wäre eher auf einfache Objekt-Literale anwendbar:</p>
<pre><code class="block language-javascript"><span class="token keyword">var</span> Foo <span class="token operator">=</span> <span class="token punctuation">{</span>
<span class="token function-variable function">func</span><span class="token operator">:</span> <span class="token keyword">function</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre>
<p>In meiner Einführung vergleiche ich das aber eher mit Singletons, weil das Objekt einen Status haben kann.</p>
<p>Wenn man in JS von statischen Eigenschaften spricht, meint man meist Eigenschaften des Konstruktors selbst. Der ist ja auch nur ein Funktionsobjekt, das Eigenschaften haben kann.</p>
<pre><code class="block language-javascript"><span class="token keyword">function</span> <span class="token function">Konstruktor</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token punctuation">}</span>
Konstruktor<span class="token punctuation">.</span>statischeEigenschaft <span class="token operator">=</span> <span class="token string">'foo'</span><span class="token punctuation">;</span>
</code></pre>
<p>Aber das ist terminologisch nicht so sauber. In JS gibt es einfach Objekte, und Funktionen sind Objekte erster Klasse. Was da eher herausfällt ist das Aufrufen von Funktionen mittels »new«.</p>
<p>Mathias</p>
<div class="signature">-- <br>
<a href="https://github.com/chaplinjs/chaplin" rel="noopener noreferrer">Chaplin - An Application Architecture Using Backbone.js</a>
</div>