Question

假设我有以下JavaScript

function myGlobalFunction(){
    function firstInnerFunction(){
         return "rainbows";
    }
    function secondInnerFunction(){
         function innerInnerFunction(){
               return "clouds";
         }
         return innerInnerFunction();
    }
    return firstInnerFunction(); //valid call
}

无论如何我可以在全局范围内调用firstInnerFunction（）吗？如果是这样（并且更好），我可以向下两级并从全局范围调用innerInnerFunction（）吗？

Answer 1

你在做那样的事情时想要达到什么目的？我建议如下：

var myGlobalFunction = { 
    var innerInnerFunction() { return "clouds"; }
    get firstInnerFunction() { return "rainbows"; }
    get secondInnerFunction() { return innerInnerFunction(); }
};

然后您可以使用以下内容调用firstInnerFunction（）：

myGlobalFunction.firstInnerFunction;

对于从全局范围调用innerInnerFunction（），myGlobalFunction.secondInnerFunction（）将起到与直接调用innerInnerFunction（）相同的目的。

Answer 2

如果要调用globalFunction来定义firstInnerFunction，可以按如下方式执行：

function globalFunction() {
    firstInnerFunction = function() { return "rainbows" ; } ;
}

对于innerInner函数，您可以执行以下操作

function globalFunction() {
    firstInnerFunction = function() { return "rainbows" ; } ;
    secondInnerFunction = function() {
        innerInnerFunction = function() { return "clouds" ; } ; }
}

现在你可以这样做

globalFunction() ; // defines firstInnerFunction and secondInnerFunction in the global scope
firstInnerFunction() ; // returns "rainbows"
secondInnerFunction() ; // defines innerInnerFunction
innerInnerFunction() ; // returns "clouds"

Answer 3

简而言之，没有。 JavaScript是功能范围的，因此内部的所有内容都是从外部隐藏的。因此，为了访问内部函数，您需要以某种方式公开它们。

绝对最简单（但丑陋）的选择是做这样的事情：

var secondInnerCopy;

function myGlobalFunction(){
    function firstInnerFunction(){
         return "rainbows";
    }
    function secondInnerFunction(){
         function innerInnerFunction(){
               return "clouds";
         }
         return innerInnerFunction();
    }
    secondInnerCopy = secondInnerFunction;
    return firstInnerFunction(); //valid call
}

myGlobalFunction();
secondInnerCopy(); //valid (only after myGlobalFunction called though)

更好的选择是重构为具有函数的对象图：

var global = {
    myGlobalFunction: function(){
        return this.inner.firstInnerFunction(); //valid call
    },
    inner: {
        firstInnerFunction: function() {
            return "rainbows";
        },
        secondInnerFunction: function(){
            return this.inner.innerInnerFunction();
        },
        inner: {
            innerInnerFunction: function(){
               return "clouds";
            }
        }
    }
};

global.myGlobalFunction();
global.inner.inner.innerInnerFunction();
//etc...

Answer 4

我不认为这是可能的，但我可能是错的。您可以通过顶级函数来执行此类操作来访问嵌套函数。

function A(x) {
   function B(y) {
      function C(z) {
         alert(x + y + z);
      }
      C(3);
   }
   B(2);
}
A(1); // alerts 6 (1 + 2 + 3)

另一个例子

function addSquares(a,b) {
   function square(x) {
      return x * x;
   }
   return square(a) + square(b);
}
a = addSquares(2,3); // returns 13
b = addSquares(3,4); // returns 25
c = addSquares(4,5); // returns 41

检查此链接，它在Javascript中有关于函数和嵌套函数的一些很好的信息。 Javascript Function Scope

Answer 5

我相信这样的事情也会奏效，不过我喜欢Alconja所做的事。

var myGlobalFunction = {
  firstInnerFunction: function(){
     return "rainbows";
  },
  secondInnerFunction : function(){
     var innerInnerFunction =  function(){
         return "clouds";
     }
     var inninnerFuncTwo = function(){
         return 'more stuff';
     }
     return {
      inn : innerInnerFunction,
      inn2: inninnerFuncTwo
      }
  }
}

myGlobalFunction.secondInnerFunction().inn();
myGlobalFunction.secondInnerFunction().inn2();

Javascript - 在全局范围内调用本地函数/属性

5 个答案: