Home » Uncategorized » JavaScript – Functions Scope / This

JavaScript – Functions Scope / This

Contents

Closures – Function Scope

Mit einer Funktion lässt sich so etwas wie eine Klassendefinition erstellen. Wird von der Funktion eine (eingebettete) Funktion zurückgegeben, dann hat diese den ganzen Scope ihrer umgebenden Funktion enthalten:

function remember(number){
   return function(){
      return number;
   }
}
f1 = remember(99);
f1();
//99

Mehrere Sub-Funktionen – die alle auch den Scope der outer Fuction – erhalten, können in einem Objekt, das zurückgegeben werden:
Die Art der Kapselung (Privat-Machung) der ‚on‚-Variable wird „Module Pattern“ genannt.

function Radio(mode) {
  let on = false;

  return {  
    mode: mode,
    turnOn: function () {  // Function returned with scope incl. the 'on' variable
      on = true;
    },
    isOn: function () { // Function returned with scope incl. the 'on' variable
      return on;
    }
  };
}

let fmRadio = Radio('fm');

fmRadio.on;
//undefined

fmRadio.isOn();
// false

fmRadio.turnOn();

fmRadio.isOn();
// true

Kontext-Unsicherheit (bei Übergabe) von Funktionen!!

Im Gegensatz zu Java können Funktionen manchmal ‚Instanz-Variablen‘ haben, manchmal aber auch nicht. Auf was die This-Referenz der Funktion zeigt kann verwirrend unterschiedlich sein.
Im obigen Beispiel ist f1 eine „Objekt-Funktion“, d.h. eine Funktion mit einem funktionsspezifischen Scope (Java-Entwickler würden von einer Instanz sprechen). Dies ist so, weil die Rückgabe einer sie umschliessenden (Objekt-Gebärer-)Funktion ist.

Intra-Objekt-Referenz

Untra-Objekt-Referenz

Keine Intra-Objekt-Corossreferenzen möglich!

{
  message : 'hello',
  logIt : function(){
          console.log('I say ' + message);
        }
}

Die Intra-Objekt-Referenz funktioniert nicht. Korrektur:

Funktion aus Objekt übergeben

Keinen non-global Closure hat hingegen eine Funktion, die zwar innerhalb eines Objektes definiert ist, die aber dann (ohne umgebendes Objekt) als Referenz über geben wird:

> const dog = {
... age: 5,
... growOneYear: function(){
..... this.age += 1;
....}
};
undefined
> dog.growOneYear();
undefined
> dog.age;
6
> function invokeTwice(cb){
... cb();
... cb();
}
undefined
> invokeTwice(dog.growOneYear); //<-- Funktion growOneYear wird nicht ausgeführt
                                //    weil trailing "()" fehlen
undefined
> dog.age;
6 //<-- Hinaufzählen hat nicht funktioniert!

Wie man sieht hat die Funktionsreferenz dog.growOneYear das age Feld nicht in seinem Scope mit genommen!

Anders sieht es wiederum aus, wenn man eine Funktion mitgibt, die durch eine andere Funktion erstellt wurde und deshalb deren Scope mit sich mit schleppt:

/* Hauptfunktion wird aufgerufen und gibt Unterfunktion zurück, die aber den Clusure hat der den Block der Hauptfunktion umfasst! */
> let catGrows = function(){
... age = 0;
... return () => {return age++;}
}(); 
undefined
> catGrows()
0
> catGrows()
1
> catGrows()
2
> invokeTwice(catGrows) /* Keine Ausgabe, aber intern wird gezählt */
undefined
> catGrows()
5
>

Das Beispiel mit dem „Function-in-Funktion-Scope“ funktioniert. Nur ist es äusserst unpraktisch, dass man nur genau über eine Funktion zugriff auf das Objekt hat.

Nur wenn die Funktion auf dem Objekt aufgerufen wird, zeigt ihr This auf das Objekt:
>dog.growOneYear()

Damit invokeTwice das richtige Resultat liefert können wir auch programmieren:

> dog.age;
6
> invokeTwice(function(){dog.growOneYear();});
undefined
> dog.age;
8

gowOneYear operiert so immer auf dem mitgegebenen dog Objekt.



Die vielversprechendere Lösung ist es, via bind() Methode, der Funktion explizit das Objekt mitzugeben, auf das die This-Referenz der Funktion zeigen soll:



> objectBoundGrowOneYearFunction = dog.growOneYear.bind(dog);
[Function: bound growOneYear]
> invokeTwice(objectBoundGrowOneYearFunction);
undefined
> dog.age;
10
>

Hinterlasse einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert