Sofort aufgerufene Funktionsausdruck

Ein Sofort aufgerufene Funktionsausdruck (oder Iife, ausgesprochen "iffy", IPA /ˈꞮf.i/) ist a Programmiersprache Idiom das produziert a lexikalischer Bereich Verwendung Funktionsvorgänge. Es war beliebt in JavaScript[1] Als Methode zur Unterstützung Modulare Programmierung vor der Einführung von standardisierteren Lösungen wie z. CommonJS und Es Module.[2]

Sofort aufgerufene Funktionsausdrücke können verwendet werden, um zu vermeiden Variable Hebezeuge aus innerhalb von Blöcken schützen vor Verschmutzung der globale Umwelt und ermöglichen gleichzeitig den öffentlichen Zugang zu Methoden, während die Privatsphäre für in der Funktion definierte Variablen beibehalten.

Verwendungszweck

Sofort aufgerufene Funktionsausdrücke können auf verschiedene Arten geschrieben werden.[3] A Gemeinsame Konvention soll den Funktionsausdruck - und optional seinen Aufrufoperator - mit dem Gruppierungsoperator einschließen.[4] in Klammern, um dem Parser ausdrücklich einen Ausdruck zu erwarten. Ansonsten in den meisten Situationen, wenn der Parser auf die trifft Funktion Schlüsselwort, es behandelt es als Funktionserklärung (Anweisung) und nicht als Funktionsausdruck.[5][6] 

(Funktion () { / * ... */ }) (); (Funktion () { / * ... */ } ()); (() => { / * ... */ }) (); // mit ES6 -Pfeilfunktionen (obwohl Klammern nur außerhalb von außerhalb erlaubt ist)

Es gibt andere Möglichkeiten, einen Funktionsausdruck durchzusetzen:

!Funktion () { / * ... */ } (); ~Funktion () { / * ... */ } (); -Funktion () { / * ... */ } (); +Funktion () { / * ... */ } (); Leere Funktion () { / * ... */ } ();

In Kontexten, in denen ein Ausdruck erwartet wird, ist nicht erforderlich, in Klammern zu wickeln:

Lassen f = Funktion () { / * ... */ } (); Stimmt && Funktion () { / * ... */ } (); 0, Funktion () { / * ... */ } ();

Das Übergeben von Variablen in den Umfang erfolgt wie folgt:

(Funktion(a, b) { / * ... */ }) ("hallo", "Welt");

Eine anfängliche Klammung ist ein Fall, in dem die Automatische Semikoloninsertion (ASI) in JavaScript kann Probleme verursachen; Der Ausdruck wird stattdessen als Aufruf zum letzten Term in der vorhergehenden Zeile interpretiert. In einigen Stilen, die optionale Semikolons weglassen, wird das Semikolon platziert vor der Klammern und ist als a bekannt Defensives Semikolon.[7][8] Zum Beispiel:

a = b + c ; (Funktion () {  // Code }) ();

... um nicht analysiert zu werden als c().

Beispiele

Der Schlüssel zum Verständnis von Designmustern wie IIFE liegt darin, zu erkennen, dass JavaScript vor ES6 nur vorgestellt wurde Funktionsumfang (so fehlt Blockbereich), Vorbeigehen Werte durch Referenz Innerhalb Schließungen.[9] Dies ist nicht mehr der Fall, da die ES6 -Version von JavaScript Blocks Scoping mithilfe des neuen implementiert Lassen und Const Schlüsselwörter.[10]

Bewertungskontext

Ein Mangel an Blockbereich bedeutet, dass Variablen, die in (zum Beispiel) a definiert sind Für Schleife wird ihre Definition "auf die Spitze der umschließenden Funktion" "gehoben" lassen. Die Bewertung einer Funktion, die von Variablen abhängt, die durch die äußere Funktion (einschließlich der Iteration) geändert wurden, kann schwierig sein. Wir können dies ohne Schleife sehen, wenn wir einen Wert zwischen dem Definieren und Aufrufen der Funktion aktualisieren.[11] 

Lassen v, Wert erhalten; v = 1; Wert erhalten = Funktion () { Rückkehr v; }; v = 2; Wert erhalten(); // 2

Während das Ergebnis bei der Aktualisierung offensichtlich erscheinen mag v Manuell kann es unbeabsichtigte Ergebnisse erzielen, wenn Wert erhalten() ist in einer Schleife definiert.

Im Folgenden geht die Funktion durch v als Argument und wird sofort aufgerufen, wobei der Ausführungskontext der inneren Funktion erhalten bleibt.[12] 

Lassen v, Wert erhalten; v = 1; Wert erhalten = (Funktion (x) {  Rückkehr Funktion () { Rückkehr x; }; }) (v); v = 2; Wert erhalten;  // 1

Dies entspricht dem folgenden Code:

Lassen v, Wert erhalten; v = 1; Funktion f(x) {  Rückkehr Funktion () { Rückkehr x; }; }; Wert erhalten = f(v); v = 2; Wert erhalten;  // 1

Festlegung privater Variablen und Zubehör

IIFes sind auch nützlich, um private Methoden für zugängliche Funktionen festzulegen und gleichzeitig einige Eigenschaften für die spätere Verwendung aufzudecken.[13] Das folgende Beispiel stammt aus Almans Beitrag zu IIFES.[1] 

// "Zähler" ist eine Funktion, die ein Objekt mit Eigenschaften zurückgibt, in diesem Fall Funktionen. Lassen Zähler = (Funktion () {  Lassen i = 0;  Rückkehr {  erhalten: Funktion () {  Rückkehr i;  },  einstellen: Funktion (val) {  i = val;  },  Zuwachs: Funktion () {  Rückkehr ++i;  }  }; }) (); // Diese Aufrufe zugreifen auf die von "Zähler" zurückgegebenen Funktionseigenschaften. Zähler.erhalten();  // 0 Zähler.einstellen(3); Zähler.Zuwachs(); // 4 Zähler.Zuwachs(); // 5

Wenn wir versuchen, zugreifen zu können counter.i aus der globalen Umgebung wird es undefiniert sein, da es in die aufgerufene Funktion eingeschlossen ist und keine Eigenschaft von ist Zähler. Ebenso, wenn wir versuchen, zugreifen zu können iDies führt zu einem Fehler, wie wir nicht erklärt haben i in der globalen Umgebung.

Terminologie

Ursprünglich als "selbst exekutierende anonyme Funktion" bekannt,[14] Ben Alman stellte später den aktuellen Begriff iife als einen semantisch genaueren Namen für die Idiom ein, kurz nach seiner Diskussion entstand auf comp.lang.javascript.[1][15][16]

Insbesondere, die sofort aufgerufene Funktionen müssen nicht anonym sein und inhärent sein, und ECMaskript Der strenge Modus von 5 verbietet Argumente.Callee,[17] Rendern des ursprünglichen Begriffs a Fehlbezeichnung.

Siehe auch

Verweise

  1. ^ a b c Alman, Ben (15. November 2010). "Sofort auf Funktionsausdrücke aufgerufen". Archiviert Aus dem Original am 1. Dezember 2017. Abgerufen 18. Januar 2019.
  2. ^ McGinnis, Tyler (15. Januar 2019). "JavaScript -Module: Von IIFes über CommonJs bis ES6 -Module". ui.dev. Abgerufen 18. August 2021.
  3. ^ Lindley, Cody (2013). JavaScript -Erleuchtung. O'Reilly. p. 61. ISBN 978-1-4493-4288-3.
  4. ^ "Gruppierbetreiber". Mozilla Developer Network.
  5. ^ Zakas, Nicholas (2012). Wartbarer JavaScript. O'Reilly. p. 44. ISBN 978-1-4493-2768-2.
  6. ^ Axel Rauschmayer. "ExploringJs".
  7. ^ "Javascript Semikolon Insertion: Alles, was Sie wissen müssen". 28. Mai 2010. Archiviert Aus dem Original am 2. Oktober 2017.
  8. ^ Marohnić, Mislav (7. Mai 2010). "Semikolons in JavaScript sind optional". Archiviert Aus dem Original am 8. August 2017.
  9. ^ Haverbeke, Marijn (2011). Eloquent JavaScript. Keine Stärkepresse. S. 29–30. ISBN 978-1-59327-282-1.
  10. ^ ECMascript 6: Neue Funktionen: Übersicht und Vergleich, Blockscoped Variablen
  11. ^ Alman, Ben. "Simple-iife-example.js". Github. Abgerufen 5. Februar 2013.
  12. ^ Otero, Cesar; Larsen, Rob (2012). Professionelle jQuery. John Wiley & Sons. p. 31. ISBN 978-1-118-22211-9.
  13. ^ Rettig, Pascal (2012). Professionelle Entwicklung von HTML5 -Handlungen für Handyspiele. John Wiley & Sons. p. 145. ISBN 978-1-118-30133-3.
  14. ^ Ressig, John (2006). Pro JavaScript -Techniken. Apress. p. 29. ISBN 978-1-4302-0283-7.
  15. ^ Osmani, Addy (2012). JavaScript -Designmuster lernen. O'Reilly. p. 206. ISBN 978-1-4493-3487-1.
  16. ^ Baagoe, Johannes. "Klammern in der Funktionsdefinition schließen, gefolgt von ihrem Aufruf". Abgerufen 19. April 2010.
  17. ^ "Strikter Modus". Mozilla Javascript Referenz. Mozilla Developer Network. Abgerufen 4. Februar 2013.

Externe Links