Schließung in JavaScript

Was ist Closing und wann können wir es wirklich nutzen?

Um Closure zu verstehen, müssen wir zwei einfache Konzepte in JavaScript kennen: verschachtelte Funktionen und die Rückgabe einer Funktion.

Verschachtelte Funktionen

In JavaScript können wir verschachtelte Funktionen haben. Die innere Funktion hat Zugriff auf die Variablen und Parameter der äußeren Funktion.

Schauen wir uns das folgende Beispiel an:

function greetPerson(name) {
  const message = 'Hello';
  
  function displayMessage() {
    console.log(`${message} ${name}!`);
  }

  displayMessage();
}

greetPerson('Alex'); // Hello Alex!

Eine Funktion zurückgeben

Neben der Deklaration und dem Aufruf einer inneren Funktion innerhalb der äußeren Funktion können wir die innere Funktion auch zurückgeben, sodass sie von außen aufgerufen werden kann.

Sehen wir uns ein Beispiel dafür an:

function greetPerson(name) {
  const message = 'Hello';
  
  function displayMessage() {
    console.log(`${message} ${name}!`);
  }

  return displayMessage;
}

const displayMessageFunction = greetPerson('Alex');

console.log(typeof(displayMessageFunction)); // function
displayMessageFunction(); // Hello Alex!

Schließung

Nachdem wir diese beiden Konzepte verstanden haben, ist die „Definition“ von Schließung ziemlich einfach.

Abschluss bedeutet, dass eine innere Funktion Zugriff auf die Variablen und Parameter ihrer äußeren Funktion hat, auch nachdem die äußere Funktion zurückgekehrt ist.

Sehen wir uns ein weiteres Beispiel an, in dem wir genau sehen können, wie der Verschluss verwendet werden kann:

function counterFunction() {
 let counter = 0;

 function increaseCounter() {
  return counter += 1;
 }

 return increaseCounter;
}

// counter reffers to the increaseCounter returned by the counterFunction
const counter = counterFunction();

console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3
console.log(counter()); // 4

Eine innere Funktion behält keine separate Kopie einer äußeren Variablen bei, sondern verweist auf die äußere Variable. Mit anderen Worten: Der Wert von counterwird geändert, wenn Sie ihn mithilfe der inneren Funktion ändern.

Die äußere Funktion counterFunctiongibt auch einen Verweis auf die increaseCounterinnere Funktion zurück. Wenn wir sie also aufrufen, wird der tatsächliche Wert der counterVariablen geändert. Auf diese Weise können wir sehen, dass die counterVariable nach jedem Aufruf einen neuen inkrementierten Wert hat counter().

Wann sollte man Closing verwenden?

Wir können den Verschluss verwenden, um eine Kapselung in JavaScript zu erreichen. Dies kann erreicht werden, indem die Detailimplementierung ausgeblendet wird. Auf diese Weise können wir private Variablen und Funktionen erstellen.

Schauen wir uns das folgende Beispiel an, in dem wir einige Daten nur mithilfe von Funktionen und Objekten kapseln möchten:

const counter = (function () {
  let privateCounter = 0;

  function changeBy(val) {
    privateCounter += val;
  }

  function increaseCounter() {
    changeBy(1);
  }

  function decreaseCounter() {
    changeBy(-1);
  }

  function decreaseCounter() {
    return privateCounter;
  }

  return { increaseCounter, decreaseCounter, getCounterValue };
})();

console.log(counter.getCounterValue()); // 0

counter.increaseCounter();
counter.increaseCounter();

console.log(counter.getCounterValue()); // 2

counter.decreaseCounter();

console.log(counter.getCounterValue()); // 1

increaseCounterWir können den Wert des Zählers von außen steuern, indem wir nur and aufrufen , und wir können den Wert erhalten, indem wir die Funktion decreaseCounteraufrufen , die sich wie ein Getter verhält.getCounterValue

Auf diese Weise können wir die publicund privateZugriffsspezifizierer simulieren und eine Kapselung erreichen.

Dies ist ein sehr wirkungsvolles Konzept in der Softwareentwicklung, da es unbeabsichtigte Änderungen an Variablen und Funktionen verhindert, die privat bleiben sollten.

Das ist alles!

Vielen Dank, dass Sie sich die Zeit genommen haben, diesen Artikel über Schließung in JavaScript zu lesen. Ich hoffe, es hat Ihnen geholfen, dieses wichtige Konzept besser zu verstehen und zu erfahren, wie es zur Kapselung und zur Erstellung privater Variablen und Funktionen verwendet werden kann!