Endlosschleife abfangen

[1UnitedPower]

Meine Herren!

Eigentlich ein ziemlich aufwändiger aufgeblähter Ersatz für eine Zeile

Das sehe ich ein wenig anders. Das static-Schlüsselwort, wie etwa in C, führt gleich ein ganz neues Konzept ein, während in JavaScript alte Konzepte wiederverwendet werden können, um das selbe Ziel zu erreichen. Ich finde JS in dieser hinsicht weniger komplex.

Aber in tamis Beispiel passieren auch mehrere Dinge, die ich mal aufschlüsseln möchte: Um über mehrere Funktionsaufrufe hinweg einen gemeinsamen Speicher zu nutzen, genügt in JS folgender Code (jsfiddle):

var count = 0;  
function foo(){  
   console.log( ++count );  
}  
foo(); // 1  
foo(); // 2

Wie auch immer, count ist jetzt anfällig gegenüber Seiteneffekten. Wenn wir eine weitere Funktion einführen, die ebenfalls ihre Aufrufe laut mitzählt, kriegen wir ein Problem (jsfiddle):

var count = 0;  
var foo = function foo(){  
   console.log( ++count );  
}  
var bar = function () {  
   console.log( ++count );  
}  
foo(); // 1  
bar(); // 2 !!!  
foo(); // 3 !!!

Hier würden beide Funktionen den selben gemeinsamen Speicher nutzen und deshalb ungewollt interferieren. Um davor zu schützen kann man Closures nutzen:

var foo = (function(){  
   var count;  
   return function(){  
      console.log( ++count );  
   }  
};  
var bar = (function(){  
   var count;  
   return function(){  
      console.log( ++count );  
   }  
};  
  
foo(); // 1  
bar(); // 1  
foo(); // 2

Diese Art von Seiteneffekten ist immer Ursache von Programmzuständen. Bei rein funktionaler Programmierung gibt es diese Fehlerklasse nicht, deshalb konnten wir sie durch Closures auflösen. Das ist übrigens ein sehr nützliche Eigenschaft von funktionalen Programmiersprachen, die sich bei Parallelisierung bemerkbar macht. Eine andere, imho. elegantere Lösung, die das selbe Prinzip nutzt, sieht so aus (jsfiddle):

var foo = function () {  
   console.log( ++this.count );  
}.bind({count: 0});  
  
var bar = function () {  
   console.log( ++this.count );  
}.bind({count: 0});  
  
foo(); // 1  
bar(); // 1  
foo(); // 2