Question

我正在构建一个相当大的JS应用程序，我希望得到你对某些逻辑的看法。我想知道通过一系列函数传递参数是否被认为是不好的做法，例如

function start(){
    var param1 = 'me';
    secondFunction(param1);
}

function secondFunction(param1){
    //i dont want to user the param in this function
    $.ajax('url',data,success(){
        third(param1);
    });
}

function third(param1){
    alert(param1);
}

我想替代方法是使用全局变量，如下所示。但在我的情况下，我已经有了大量的全局变量，在我看来，有些事情对于应用程序的全局工作来说并不重要。

var param1;

function start(){
    param1 = 'me';
    secondFunction();
}

function secondFunction(){
    //i dont want to user the param in this function
    $.ajax('url',data,success(){
        third();
    });
}

function third(){
    alert(param1);
}

那么你会说通过多个函数传递参数是好的还是我应该用另一种方式呢？

由于

Answer 1

实际上，这是一种很好的做法，因为它避免了任何全局状态（即理想情况下，函数的行为只取决于其参数）。

如果你有很多参数要通过这种方式传递，我会在一个单独的对象（一个'环境'对象）中将它们一起批处理，但除此之外它完全没问题。

这样做可以提供很大的灵活性 - 如果你想让一个函数对不同的数据进行一次操作，你只需要传递不同的值，而不是改变全局状态，这可能会影响其他一切（没有这样的全局副作用使得很容易并行化函数，即使这对JavaScript来说可能并不那么重要。）

Answer 2

通过多个使用全局变量的函数传递参数要好得多。

例如，它允许您多次启动该过程而不会弄乱全局状态。

Answer 3

长话短说，我会坚持传递变量以避免范围冲突并保持同时调用正常运行。但是，我会更改传递它们的格式：

因为JavaScript对象非常灵活，所以我喜欢为可能需要多个参数的函数提供单一的全包参数。这样可以在调用函数时提高可见性，从而可以轻松扩展函数以支持其他参数和可选参数，在您的情况下，可以轻松地将参数传递给链中的其他函数。一个缺点是更长的函数调用，但我认为这些优点非常值得。例如：

/**
 * ..
 *
 * params.test1 Test 1 does blah
 * params.test2 Test 2 does blah 2
 * params.test3 Test 3 does blah 3
 * params.test4 Test 4 does blah 4
 */
function test(params){
    //Initialize Parameters
    var test1 = params.test1;
    var test2 = params.test2;

    //function code
    ..
    test2(params);
    ..
}

/**
 * ..
 *
 * params.test1 Test 3 does blah 3
 * params.test2 Test 4 does blah 4
 */
function test2(params){
    var test3 = params.test3;
    var test4 = params.test4;

    //function code using test3 and test4
    ..
}

//Call the test function
test({test1: 'foo1', test2: 'foo2', test3: 'foo3', test4: 'foo4'});

Answer 4

我认为这两种风格都没有错。这里的偏好方法，真的。

全局变量的一个缺点是它们会在应用程序的生命周期内保留在内存中。

Answer 5

javascript有一种特定的方式来定义变量，在第一个例子中你在start中定义了param1，所以所有线程和在start函数的上下文中调用的函数都有变量param1“inherit”to以某种方式打电话。所以在start之外使用的所有语句都没有定义变量param1。所以你需要使用这个变量作用域，只有当你需要在一个线程或一系列被调用的函数中使用变量时。

第二个示例，使用全局变量作用域，这意味着无论您调用它的线程，该变量都与全局值一起使用，这仅适用于您未在另一个上下文中再次定义param1的情况。

所以取决于你要做什么，在上面的例子中，最有效的是第二个

Answer 6

这是一个有点难以回答的问题，因为这完全取决于手头的任务。

将参数传递给每个函数的原因是您可能希望将这些函数重用于其他目的或以不同的顺序。在这种情况下，你肯定想继续传递参数。

如果第二个函数只能由第一个函数使用，那么创建一个包装东西的函数/对象将是一个很好的方法。

var ObjectName = {
  var param = null;

  function mainFunc(p) {
    pararm = p;
    func2();
  }

  function func2() {
    // Use "param"
    func3();
  }

  function func3() {
    // Use "param"
  }
}

// At this level of the code, the param variable is out of scope.

Answer 7

太多的全局变量是个坏主意：你会忘记什么是服务什么的。

函数中的参数太多是一个坏主意：调用哪些参数与哪些函数相关会变得令人困惑/难以理解。

你可以先重新思考你的设计。

按照对象对它们进行分组，正如Alexander Gessler建议的那样是个好主意。

另一个想法是为你的函数/变量创建不同的范围......（不一定在对象中）。如果您愿意，可以使用函数中的函数。

Answer 8

这样的事情对你有好处。

var cakes = function() {
    // Sets a varable called param1, will use it in the prototype below
    this.param1 = 'i like cakes';
    // Calls the init prototype, setup below.
    this.init();
};

cakes.prototype = {
    init: function() {
        // this.param1 is set above.
        console.log(this.param1);
        $.ajax({
            // For example I'm just passing back the page which this javascript is in, so something returns
            url: window.location.href,
            // _this stores the full object, so you can get it in the callback below.
            _this: this,
            // success calls the ajaxCallback function, below
            success: this.ajaxCallback
        });
    },
    ajaxCallback: function() {
        // this here refers to the ajax call
        console.log(this);
        // this._this refers to the original object, captured above.
        console.log(this._this);
        // this._this.param1 refers to the text set above.
        console.log(this._this.param1);
    }
};

// Make sure you include this or it won't work
var x = new cakes();
// or you could just do this if you are only planning on using one instance of this object on a page.
// new cakes();

Answer 9

不要害怕使用私有变量，这里是quick sample on jsbin。它可能不符合您的需要，但需要注意的重要一点是，您并不总是在全局参数和参数之间进行选择。中间有很多选择。

var MyNamespace = function () {

    // private variable
    var myPrivateVariable = 'me';

    // private methods
    var secondFunction = function () { };

    // return an object, this becomes MyNamespace
    return {
        // expose a method called start
        start: function (arg1) {
            // take the arg and assign it to a private
            myPrivateVariable = arg1;

            // call a private variable, we can only call / access privates from within the returned object assigned to MyNamespace
            secondFunction();
        },
        // expose a method called third
        third: function () {
            // alert out our private variable
            alert(myPrivateVariable);
        }
    }; 

} ();  // here we're assigning the result of this function call to MyNamespace and closing around all the privates



// Usage:
MyNamespace.start('me');

MyNamespace.third();

Answer 10

传递参数非常合理，实际上是唯一可行的方法，如果你有一个异步的ajax调用。在ajax调用第一次start（）调用的回调之前，您无法保证全局变量可能会被另一个start（）调用覆盖。

通过一系列函数参数是不好的做法？

10 个答案: