JavaScript-ის closures-ები

Closure-ები არის ჯავასკრიპტის ფუნქციები, რომლებიც იმახსოვრებენ მოცემული ფუნქციის გარე ბლოკის ცვლადებს (outer scope) მიუხედავად იმისა, შესრულდა თუ არა გარე ბლოკის ფუნქცია.

Closure იქმნება მაშინ, როდესაც ფუნქცია აღწერილია სხვა ფუნქციის შიგნით.

მაგალითი 1:

function outerFunction() {
    let outerVariable = 'I am from the outer function';

    function innerFunction() {
        console.log(outerVariable); // Accessing outerVariable
    }

    return innerFunction;
}

const closureFunction = outerFunction(); // outerFunction returns innerFunction
closureFunction(); 
// Output: I am from the outer function

მოცემულ მაგალითში გვაქვს გარე ფუნქცია სახელად outerFunction() ხოლო ამ ფუნქციის ბლოკში გვაქვს კიდევ ერთი ფუნქცია აღწერილი, რომლის სახელიცაა innerFunction(), ასევე outerFunction()-ში გვაქვს აღერილი ცვლადი სახელად outerVariable.

მიუხედავად იმისა, რომ innerFunction()-ში არ გვაქვს არანაირი ცვლადი მას შესაძლებლობა აქვს მისწვდეს მშობელი outerFunction()-ის ბლოკში არსებულ ცვლადებს და შესაბამისად გამოვიყენოთ ისინი.

მაგალითი 2:

function createCounter() {
    let count = 0;

    return function() {
        count++; // შიდა ფუნქცია უკეთებს მოდიფიკაციას count ცვლადს, რომელიც აღწერილია მისი მშობელი ფუნქციის ბლოკში
        return count;
    };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

მოცემული მაგალითის მიხედვით ასევე შესაძლებლობა გვაქვს count ცვლადის ცვლილების შიდა ფუნქციაში, ასევე როდესაც counter-ს ვანიჭებთ ფუნქციას createCounter() და გამოვიძახებთ რამდენჯერმე, დავინახავთ, რომ count ცვლადი ინახავს მის წინა მნიშნველობას, შესაბამისად ყოველ გამოძახებაზე count ცვლადი გაიზრდება 1-ით.

რეალური მაგალითები closure-ებზე

მოვიყვანოთ რეალური მაგალითი, სადაც count ცვლადი აღწერილი გვაქვს ე.წ. გლობალურ ბლოკში (global scope)

let count = 0; // გლობალური ცვლადი

function createCounter() {
    return function() {
        count++;
        return count;
    };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
count = 42; // შემთხვევითი მოდიფიკაცია
console.log(counter()); // 43

თუ დავაკვირდებით count ცვლადს შემთხევით შესაძლოა მივანიჭოთ რაიმე არასასურველი მნიშვნელობა, რაც გამოიწვევს შედეგის შეცვლას.

რატომ უნდა გამოვიყენოთ closure-ები ჯავასკრიპტში?

1. თავიდან ვიცილებთ გლობალური ბლოკის დაბინძურებას (global scope)
   • მაგალით 2-ში count ცვლადი მიუწვდომელია გლობალური ბლოკიდან (global scope)
2. ენკაფსულაცია
   • ჩვენ შეგვიძლია ლოკალურად ავღწეროთ ცვლადები
3. უსაფრთხოება
   • ე.წ. პრივატული ცვლადებით მანიპულაცია შეგვიძლია ზუსტად ისე, როგორც ჩვენ ლოკალურად ფუნქციის ბლოკში გვაქვს აღწერილი და ვიზღვევთ თავს შეცდომებისგან

მოცემული მაგალითებით შევეცადე მარტივად ამეხსნა თუ რა არის closure ჯავსკრიპტში და რაში შეიძლება მათი გამოყენება.