JavaScript - Wie rufe ich eine Funktion innerhalb einer Funktion auf?

Question

ich den folgenden JavaScript-Code haben:

function parentFunc() { 

    function childFunc() { 
     ... 
    } 

    ... 
} 

// outside of myParentFunc, how do I call myChildFunc() ? 
childFunc(); // doesn't work 

Wie rufe ich childFunc() von außerhalb parentFunc()?

UPDATE:

weiß, dass ich die offensichtliche Antwort childFun außerhalb von parentFun, aber dies ist ein Dritte-Bibliothek, die ich ändern kann, sich nicht zu bewegen wäre.

Answer 1

einfach erklärt es außerhalb der Funktion o_O

Nun, wenn die Bibliothek nicht einen Weg, es zu tun liefert, ändern Sie es und laden Sie es mit Ihrem Js, wahrscheinlich die Bibliothek ist nicht zulassen, um es zu tun, weil du es nicht solltest.

Answer 2

Dies wäre eine Möglichkeit, wie Sie es tun könnten.

var myChildFunction; 

function myParentFunc() { 
    //.... 
    myChildFunction = function() { 
    //.... 
    } 
    myChildFunction(); 
} 

myChildFunction(); 

Hier ist eine andere Art und Weise

var myChildFunction = function() { 
    //....  
} 


function myParentFunc() { 
    //.... 
    myChildFunction(); 
} 

myChildFunction(); 

Answer 3

function parentFunc() { 

    var childFunc = function() { 
     ... 
    } 

    ... 
} 

childFunc(); // works 

Answer 4

exposing inner functions zur Außenwelt sehen.

Answer 5

Möglicherweise möchten Sie mit der Yahoo Module Pattern stattdessen berücksichtigen:

myModule = function() { 

    //"private" variables: 
    var myPrivateVar = "I can be accessed only from within myModule." 

    //"private" methods: 
    var myPrivateMethod = function() { 
     console.log("I can be accessed only from within myModule"); 
    } 

    return { 
     myPublicProperty: "I'm accessible as myModule.myPublicProperty." 

     myPublicMethod: function() { 
      console.log("I'm accessible as myModule.myPublicMethod."); 

      //Within myModule, I can access "private" vars and methods: 
      console.log(myPrivateVar); 
      console.log(myPrivateMethod()); 
     } 
    }; 
}(); 

Sie definieren Ihre private Mitglieder, wo myPrivateVar und myPrivateMethod definiert sind, und Ihre öffentlichen Mitgliedern wo myPublicProperty und myPublicMethod definiert sind.

Sie können einfach die öffentlichen Methoden und Eigenschaften zugreifen, wie folgt:

myModule.myPublicMethod(); // Works 
myModule.myPublicProperty; // Works 
myModule.myPrivateMethod(); // Doesn't work - private 
myModule.myPrivateVar;  // Doesn't work - private 

Answer 6

Wenn Sie absolut nicht den Code ändern kann, gibt es keine Möglichkeit, es zu tun. Ansonsten weisen Sie die innere Funktion auf etwas können Sie zugreifen, indem Sie die Zeile ändern

function childFunc() { 

, sagen wir,

window.cf = childFunc() { 

dann können Sie die Funktion durch die cf Variable zugreifen. (Es gibt viele andere Möglichkeiten, dies zu tun; dies ist der, der die geringste Änderung im Code von Drittanbietern erfordert.)

Answer 7

Hier ist, was Sie tun können:

die innere Funktion zur globalen anbringt:

function parentFunc() { 

    window.childFunc = function(){ 

    } 

} 

Dies ist eine Art Ghetto aber :)

Also ich würde einige der mehr verwenden ausgeklügelte OO-Muster, wie das Modul Muster:

function parentFunc() { 

    var someVar; 

    var childFunc = function(){ 

    }; 


    return { 
     childFunc, 
     someVar 
    } 

} 

parentFunc.childFunc(); 

Auf diese Weise können Sie yo zurückkehren Ihre innere Funktion und Ihr Rückgabewert.

Denken Sie daran, die Tatsache, dass Sie Ihre innere Funktion nicht nennen können, ist ein Merkmal von JS keine Einschränkung.

Answer 8

Es gibt einen Weg, dies sehr einfach zu tun, aber es ist auch eine sehr schlechte Praxis, sich darauf einzulassen. Da jedoch OCCATIONALLY globale Variablen nützlich sind, werde ich dies erwähnen. Bitte beachten Sie, dass in der Situation, die Sie beschreiben, kein gutes Beispiel für die Verwendung globaler Variablen ist.

Der folgende Code funktioniert, aber ist schrecklichen Code.

function parentFunction() { 
    ... 
    childFunction = function() { 
    ... 
    } 
} 

childFunction(); 

Sie machen childFunction global, was im Allgemeinen eine schreckliche Idee ist. Die Verwendung von Namespaces ist eine Möglichkeit, den globalen Variablenwahnsinn zu umgehen.

ABV = {}; 
ABV.childFunction = function() { 
    ... 
} 
ABV.parentFunction = function() { 
    ... 
    ABV.childFunction(); 
    ... 
} 
ABV.childFunction(); 

So funktionieren Bibliotheken wie DWR und so. Sie benutzen 1 globale Variable und setzen alle ihre Kinder in diese eine globale Variable.

Es ist sehr wichtig, darüber nachzudenken, wie der Scope in JavaScript funktioniert. Wenn Sie anfangen, globale Variablen herumzuschleudern, werden Sie in viele Schwierigkeiten geraten. Aus dem Beispiel, das Sie verwenden, ist klar, dass Sie etwas wie eine Klasse von "Funktionen" benötigen, die Sie von überall anrufen können. Ich hoffe, das hilft.