Блог

в javascript есть особый способ определения переменных области видимости, в первом примере вы определяете param1 в start , поэтому все созданные потоки и функции, которые были вызваны в контексте функций start, имеют переменную param1 «inherit» для вызова каким-либо образом. таким образом, все операторы, используемые вне start, не имеют определенной переменной param1. Итак, вам нужно использовать эту область видимости переменной, только когда вам нужно использовать переменную в потоке или серии вызываемых функций.

во втором примере используется глобальная переменная scope, это означает, что переменная используется с глобальным значением независимо от того, в каком потоке вы ее вызвали, это применимо, только если вы не определяете снова param1 внутри другого контекста.

итак, зависит от того, что вы пытаетесь сделать, в приведенном выше примере наиболее эффективным является второй

Это несколько сложный вопрос для ответов, поскольку все зависит от решаемой задачи.

Причина передачи параметра каждой функции заключается в том, что вы можете захотеть повторно использовать функции для других целей или в другом порядке. В такой ситуации вы определенно хотите продолжать передавать параметр.

Если вторые две функции будут использоваться только первой функцией, то создание функции / объекта, который оборачивает вещи, было бы хорошим подходом.

 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.
  

Слишком много глобальных переменных — плохая идея: вы потеряете представление о том, что-обслуживать-что.

Слишком много параметров в функции — плохая идея: станет запутанным / трудно вспомнить, какие параметры идут с какими функциями.

Вы могли бы начать с переосмысления вашего дизайна в первую очередь.

Группировка их по объекту, как предложил Александр Гесслер, является хорошей идеей.

Другая идея заключается в создании другой области видимости для вашей функции / переменных… (не обязательно в объекте). Функции в функциях, если вы предпочитаете.

Что-то вроде этого было бы хорошо для вас.

 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();
  

Не бойтесь использовать частные переменные, вот краткий пример на 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();
  

Передача параметра через является абсолютно разумным и фактически единственным возможным способом, если у вас есть асинхронный вызов ajax. Вы не можете гарантировать, что глобальная переменная может быть перезаписана другим вызовом start(), пока ajax не вызовет обратный вызов первого вызова start().