Закрытие Javascript Объяснение

Вопрос: Кажется, что существует множество преимуществ для закрытий, но каковы негативы? Кроме того, правильно ли я понимаю, что Closures? Наконец, как только замыкания создаются, они могут быть уничтожены?

Я немного читал о закрытии Javascript. Я надеюсь, что кто-то немного более осведомлённый будет руководствоваться моими утверждениями, исправляя меня, где неправильно.

Преимущества закрытия:

  • Инкапсулировать переменные в локальную область, используя внутреннюю функцию. Анонимность функции несущественна.

То, что я нашел полезным, - это сделать некоторые базовые тесты, касающиеся локальной/глобальной области:

<script type="text/javascript">

   var global_text  = "";
   var global_count = 0;
   var global_num1  = 10;
   var global_num2  = 20;
   var global_num3  = 30;

   function outerFunc() {

      var local_count = local_count || 0;

      alert("global_num1: " + global_num1);    // global_num1: undefined
      var global_num1  = global_num1 || 0;
      alert("global_num1: " + global_num1);    // global_num1: 0

      alert("global_num2: " + global_num2);    // global_num2: 20
      global_num2  = global_num2 || 0;         // (notice) no definition with 'var'
      alert("global_num2: " + global_num2);    // global_num2: 20
      global_num2  = 0;

      alert("local_count: " + local_count);    // local_count: 0

      function output() {
         global_num3++;

         alert("local_count:  " + local_count  + "\n" +
               "global_count: " + global_count + "\n" +
               "global_text:  " + global_text
              );

         local_count++; 
      }

      local_count++;
      global_count++;

      return output;  
   }  

   var myFunc = outerFunc();

   myFunc();
      /* Outputs:
       **********************
       * local_count:  1
       * global_count: 1
       * global_text: 
       **********************/

   global_text = "global";
   myFunc();
      /* Outputs:
       **********************
       * local_count:  2
       * global_count: 1
       * global_text:  global
       **********************/

   var local_count = 100;
   myFunc();
      /* Outputs:
       **********************
       * local_count:  3
       * global_count: 1
       * global_text:  global
       **********************/


   alert("global_num1: " + global_num1);      // global_num1: 10
   alert("global_num2: " + global_num2);      // global_num2: 0
   alert("global_num3: " + global_num3);      // global_num3: 33

</script>

Интересные вещи, которые я извлек из него:

  • Предупреждения в outerFunc вызываются только один раз, то есть когда вызов externalFunc назначается myFunc (myFunc = outerFunc()). Это назначение, по-видимому, сохраняет openFunc открытым, в том, что я хотел бы назвать постоянным состоянием.

  • Каждый раз, когда вызывается myFunc, выполняется возврат. В этом случае возврат является внутренней функцией.

  • Что-то действительно интересное - это локализация, возникающая при определении локальных переменных. Обратите внимание на разницу в первом предупреждении между global_num1 и global_num2, даже до того, как переменная пытается быть создана, global_num1 считается undefined, потому что 'var' использовался для обозначения локальной переменной этой функции. - Об этом говорили раньше, в порядке работы для механизма Javascript, просто приятно видеть, как это работает.

  • Глобалы все еще можно использовать, но локальные переменные будут переопределять их. Обратите внимание, что перед третьим вызовом myFunc создается глобальная переменная с именем local_count, но она не влияет на внутреннюю функцию, которая имеет переменную, которая имеет одно имя. И наоборот, каждый вызов функции имеет возможность изменять глобальные переменные, как заметил global_var3.

Пост мысли: Несмотря на то, что код прост, он загроможден оповещениями для вас, поэтому вы можете подключаться и играть.

Я знаю, что есть другие примеры замыканий, многие из которых используют анонимные функции в сочетании с циклами, но я думаю, что это хорошо для 101-стартового курса, чтобы увидеть эффекты.

Единственное, о чем я беспокоюсь, это негативное влияние закрытия на память. Поскольку он сохраняет открытую функциональную среду, он также сохраняет эти переменные, хранящиеся в памяти, что может/не иметь последствий для производительности, особенно в отношении обходов DOM и сбора мусора. Я также не уверен, какую роль это будет играть в плане утечки памяти, и я не уверен, что закрытие может быть удалено из памяти простым "delete myFunc;."

Надеюсь, это поможет кому-то,

vol7ron

ОТВЕТЫ