JavaScript හි ගෝලීය කවුන්ටර් විචල්යය

විචල්යය num ශ්‍රිත වලින් පිටතට ගෙන එය ගෝලීය එකක් බවට පත් කරමු:

javascriptlet num = 1; // ගෝලීය විචල්යය

function test() {
  return function() {
    console.log(num);
    num++;
  };
}

මෙම අවස්ථාවේදී, ආපසු ලබා දෙන සියලුම ශ්‍රිත මෙම ගෝලීය විචල්යය වෙනස් කරනු ඇත, එවිට කවුන්ටර් එකිනෙකා මත රඳා පවතින ආකාරයෙන් ක්‍රියා කරනු ඇත:

javascriptlet num = 1;

function test() {
  return function() {
    console.log(num);
    num++;
  };
}

let func1 = test(); // පළමු කවුන්ටරය
func1();  // 1 ප්‍රතිදානය කරයි
func1();  // 2 ප්‍රතිදානය කරයි

let func2 = test(); // දෙවන කවුන්ටරය
func2();  // 3 ප්‍රතිදානය කරයි
func2();  // 4 ප්‍රතිදානය කරයි

අපගේ පෙර කේතය ස්වාධීන කවුන්ටර් තනා ගත්තේ ඇයි? මම මෙම කේතය මතක් කර දෙමි:

javascriptfunction test() {
  let num = 1;
  
  return function() {
    console.log(num);
    num++;
  };
};

කාරණය වන්නේ num විචල්යය test ශ්‍රිතය තුළදී ස්ථානීය වීමයි. එබැවින් සෑම test කැඳවීමක්ම එහිම ස්ථානීය විචල්යය උත්පාදනය කරයි.

එබැවින්, ආපසු ලබා දෙන ශ්‍රිත test ශ්‍රිතයේ එක් එක් ස්ථානීය විචල්යය වෙත යොමු වනු ඇත. ස්වාධීන ක්‍රියාකාරිත්වය සාක්ෂාත් කර ගන්නේ එලෙසිනි.

num ගෝලීය විචල්යයක් බවට පත් කරන්නේ නම් - එය ද ක්ලෝෂරයක් වනු ඇත. සරලව කිවහොත්, ආපසු ලබා දෙන ශ්‍රිතවල වාග්-පරිසර එකම num විචල්යය වෙත යොමු වේ - මෙම විචල්යයේ ඕනෑම වෙනසක් සියලුම ශ්‍රිතවල දෘශ්‍යමාන වනු ඇත.

javascriptlet counter = 0;
    
function test() {
  return function() {
    console.log(counter);
    counter++;
  };
}

let func = test;

let func1 = func();
let func2 = func();
func1();
func2();
func1();
func2();

javascriptfunction test() {
  let counter = 0;
  
  return function() {
    return function() {
      console.log(counter);
      counter++;
    };
  };
}

let func = test()();

let func1 = func;
let func2 = func;
func1();
func2();
func1();
func2();

javascriptfunction test() {
  let counter = 0;
  
  return function() {
    return function() {
      console.log(counter);
      counter++;
    };
  };
}

let func = test();

let func1 = func();
let func2 = func();
func1();
func2();
func1();
func2();