javascript Exécution d'une fonction sous une autre fonction

Question

J'ai 3 fonctions, avec la troisième fonction sous la première que je veux exécuter dans la seconde.

function first() { 
    function third() { 
    } 
} 

function second() { 
    third(); 
} 

Comment puis-je effectuer une deuxième exécution en troisième correctement?

Merci.

Answer 1

Cela dépend de la façon dont vous voulez configurer la première fonction et comment vous voulez y accéder. Fondamentalement, la troisième méthode est privée à la première. Vous aurez besoin d'une méthode publique au premier rang pour appeler le troisième. Cette méthode serait appelée par seconde.

Il existe différentes façons de le faire, celui qui vient à l'esprit est ...

Edit: Je l'ai appelé les paramètres un peu mieux, de cette façon son pas « PARAM » et encore.

function first() 
{ 
    // define first's private 
    var third = function(third_param) 
    { 
     alert(third_param); 
    } 

    // define first's public that calls the private 
    this.callThird = function (call_third_param) 
    { 
     third(call_third_param); 
    } 

} 

function second() 
{ 
    // get an instance of first 
    var temp = new first(); 

    // call the public method on it 
    temp.callThird('argument'); 
} 

Si vous ne se soucient pas de troisième étant privé, vous pouvez faire

function first() { } 

// public method 
first.prototype.third = function(third_param) 
{ 
    alert(third_param); 
} 


function second() 
{ 
    // get an instance of first 
    var temp = new first(); 

    // call the public method on it 
    temp.third('argument'); 
} 

ou, de cette façon, c'est pas non plus en utilisant privates

function first() 
{ 
    // the "this", makes it public 
    this.third = function(third_param) 
    { 
     alert(third_param); 
    } 

} 

function second() 
{ 
    // get an instance of first 
    var temp = new first(); 

    // call the public method on it 
    temp.third('argument'); 
} 

Si vous essayez pour faire juste un genre d'espace de noms, vous pouvez le faire (pas de privates aussi)

// define an object and name it first 
var first = 
{ 
    // give first a public variable but make it a function with an arg 
    third : function(third_param) 
    { 
     alert(third_param); 
    } 

} 

function second() 
{ 
    // call the third method on the first variable 
    first.third('argument'); 
} 

Mais sans doute la meilleure façon est via des espaces de noms

var first = (function() { 
    // define first's private function, store it in 'third', a private variable 
    var third = function (third_param) { 
     alert(third_param); 
    }; 

    // return this object to the 'first' variable 
    return { // define first's public that calls the private 
     'callThird': function (call_third_param) { 
      third(call_third_param); 
     } 
    }; 
}()); // this line runs the function, closure'ing over the privates and 
// returning an object (that has access to the privates) to the 'first' variable 

function second() { 
    // usage: 
    first.callThird("Hello World!"); 
} 

Answer 2

Javascript ne le permettra pas facilement, pourquoi auriez-vous besoin de le faire en premier lieu, vous pourriez vouloir utiliser des objets ou des prototypes pour accomplir cela.

function first(){ 
    third(); 
} 

function second(){ 

} 

function third(){ 
    second(); 
} 

Answer 3

Pourquoi ne faites-vous pas la troisième() une fonction non imbriquée sous le premier(), puis juste avoir d'abord() et deuxième() appel du troisième() ?

par exemple.

function first(){ 
    third(); 
} 

function second(){ 
    third(); 
} 

function third(){ 

} 

Answer 4

Votre meilleur pari est de tirer la fonction que est commune à la fois, et simplement l'appeler en cas de besoin.

var thirdf = function third() { 
} 

function first() { 
    thirdf(); 
} 

function second() { 
    thirdf(); 
} 

Answer 5

Faire d'abord le premier retour. Cette suggestion est plus logique si votre exemple ressemble plus à ceci:

 
function first(foo) { // notice that foo is local to first 
    function third() { 
    // do something with foo in the outer scope 
    } 
    return third; 
} 

function second(bar) { 
    bar(); // call whatever gets passed in 
} 

second(first()); // third (created inside first) gets passed to second 

Si vous ne disposez pas des variables qui sont locales d'abord (contrairement à mon exemple, où je foo), il n'y a pas de point de ne pas définir troisième dans l'espace de noms global-à-dire que vous devez faire ceci:

 
function first() { 
} 

function second() { 
    third(); 
} 

function third() { 
} 

Answer 6

en laissant de côté tous les « pourquoi voudriez-vous faire cela? » questions, et en supposant que vous devez faire cela pour une raison légitime comme l'accès à une fonction « privée » à l'intérieur du code existant que vous ne possédez pas, est ici un hack:

first.toString() vous donnera toute la source du fonction.Vous pouvez injecter un peu de code dans cette fonction pour vous renvoyer une référence à la troisième fonction:

var prober = new Function(
    first.toString().replace("{", "{ return third;") + "return first()"); 
var third = prober(); 
third(); // yay! 

Mais, s'il vous plaît ne le faites pas si vous ne avez pas vraiment besoin. C'est un gros bidouillage que je voulais juste mentionner à des fins éducatives.