Question

我的功能相当复杂。它需要几个参数，其中一个是API中的对象。它从该对象中提取信息，执行一些检查并将结果存储在变量中，然后对这些变量和参数进行多次操作。

为了使这个更易于管理，我将这些多个操作拆分为更小的功能，并将它们移出主要功能。问题是我需要将所有变量和参数从main函数传递给其他变量和参数才能使它们起作用。

我知道我可以将它们放在一个对象中并将该对象传递给子函数，但我想知道是否有办法做这样的事情：

function main(obj, arg2, arg3, arg4) {
  /* Multiple checks with values of obj */
  var myVar1 = result1;
  var myVar2 = result2;
  /* More variables here */

  subFunction1();
  subFunction2();
  subFunction3();
}

function subFunction1() {
  /* Has access to all variables and arguments from main() */
}
function subFunction2() {
  /* Has access to all variables and arguments from main() */
}
function subFunction3() {
  /* Has access to all variables and arguments from main() */
}

我不愿意使用对象主要是因为我需要让每个子函数从中提取信息并在本地重新定义变量。

我在ES3环境中需要这个，但是我可以听到以后的规格中的功能，以防它们适用于未来的情况。

Answer 1

只需在适当的上下文中移动函数，这在Javascript中是完全合法的：

function main(obj, arg2, arg3, arg4) {
  /* Multiple operations with values of obj */
  var myVar1 = result1;
  var myVar2 = result2;
   /* More variables here */
  function subFunction1() {
    /* Has access to all variables and arguments from main() */
  }
  function subFunction2() {
    /* Has access to all variables and arguments from main() */
  }
  function subFunction2() {
    /* Has access to all variables and arguments from main() */
  }
 subFunction1();
 subFunction2();
 subFunction3();
}

Answer 2

如果您确实需要父函数中的所有变量，最简单的方法是在main函数的底部定义子函数，因此它们具有相同的范围。如果你想在其他地方重用subFunction，它将无法工作。

你给出的例子更加耦合，但是如果他们都需要使用相同的变量那么有意义。

function main(obj, arg2, arg3, arg4) {
  /* Multiple operations with values of obj */
  var myVar1 = result1;
  var myVar2 = result2;
  /* More variables here */

  subFunction1();
  subFunction2();
  subFunction3();

  function subFunction1() {
    /* Has access to all variables and arguments from main() */
  }
  function subFunction2() {
    /* Has access to all variables and arguments from main() */
  }
  function subFunction2() {
    /* Has access to all variables and arguments from main() */
  }
}

您可以选择进行某种初始化，如下所示：

function init(obj, arg2, arg3, arg4) {
  /* Multiple operations with values of obj */
  var myVar1 = result1;
  var myVar2 = result2;
  /* More variables here */

  function subFunction1() {
    /* Has access to all variables and arguments from main() */
  }
  function subFunction2() {
    /* Has access to all variables and arguments from main() */
  }
  function subFunction3() {
    /* Has access to all variables and arguments from main() */
  }

  return {
     subFunction1,
     subFunction2,
     subFunction3
  }
}

var service = init(obj, arg2, arg3, arg4);
service.subFunction1();
service.subFunction2();
service.subFunction3();

在这种情况下，这些功能也将共享相同的范围。

Answer 3

即使这不是您正在搜索的内容，也许这会对您有所帮助：

var main = {
 /* Multiple operations with values of obj */
 myVar1: "hallo",
 myVar2: "welt",
 /* More variables here */

 x: subFunction1
}

function subFunction1() {
 /* Has access to all variables and arguments from main() */
 console.log(this.myVar1)
}

main.x()

https://jsfiddle.net/7x275ruz/

Answer 4

你所要求的被认为是错误的编码实践，将参数传递给functions将是一个更好的解决方案，因为现在你需要存储一些全局变量（我对可能的内容有非常有限的了解） ES3），但这是你如何解决它。

var APIobj = undefined;
var argument2 = undefined;
var argument3 = undefined;
var argument4 = undefined;

function main(obj, arg2, arg3, arg4) {

  APIobj = obj;
  argument2 = arg2;
  argument3 = arg3;
  argument4 = arg4;

  subFunction1();
  subFunction2();
  subFunction3();
}

function subFunction1() {
  /* Has access to APIobj, argument2, argument3 and argument4 */
}
function subFunction2() {
  /* Has access to APIobj, argument2, argument3 and argument4 */
}
function subFunction2() {
  /* Has access to APIobj, argument2, argument3 and argument4 */
}

我觉得你不想把这个函数放在main中，因为它会使main函数膨胀过多，所以你宁愿把它分开，然后调用main中的分离函数

Answer 5

您可以使用定义主要内部的子功能，例如：

function main(){
  // ...
  function subfunction(){}
  function subfunction2(){}
  // ...
}

或者你在main（）的原型上定义它，其中main将是一个构造函数。

function main() {
  // variables and codes...
}

main.prototype.subfunction1 = function() {}
main.prototype.subfunction2 = function() {}

在第二种情况下，您必须使用this上下文访问变量，例如this.var1和使用new main()调用的主要

Answer 6

我同意Pavlo的回答，我建议你将必要的参数传递给你的函数，保持良好的编码实践。但如果您不介意使用脏解决方案，那么这就是黑客攻击：

function main() {
  var myVar1 = 1;
  var myVar2 = 2;
  var myVar3 = 3;

  eval(function1.toString() + function2.toString() + function3.toString());
  function1();
  function2();
  function3();
}

function function1() {
  console.log(myVar1);
}
function function2() {
  console.log(myVar2);
}
function function3() {
  console.log(myVar3);
}

main();

您还可以使用call()或apply()（与ES3兼容）将您声明的函数的上下文更改为您希望它们具有的任何上下文：

function main() {
  this.myVar1 = 1;
  this.myVar2 = 2;
  this.myVar3 = 3;

  function1.call(this);
  function2.call(this);
  function3.call(this);
}

function function1() {
  console.log(this.myVar1);
}
function function2() {
  console.log(this.myVar2);
}
function function3() {
  console.log(this.myVar3);
}

main();

但是，在这种特定情况下，您根本不需要使用call()，正如您在此处所见：

function main() {
  this.myVar1 = 1;
  this.myVar2 = 2;
  this.myVar3 = 3;

  function1();
  function2();
  function3();
}

function function1() {
  console.log(this.myVar1);
}
function function2() {
  console.log(this.myVar2);
}
function function3() {
  console.log(this.myVar3);
}

main();

您可以通过clicking here了解关键字this的工作原理。

使函数从它调用的函数继承所有变量

6 个答案: