M

MLOG

Latviešu

Izpētiet JavaScript closure, izmantojot praktiskus piemērus, izprotot, kā tie darbojas un kādi ir to reālās pasaules pielietojumi programmatūras izstrādē.

JavaScript Closure: Demistifikācija ar praktiskiem piemēriem

Closure ir būtisks jēdziens JavaScript, kas bieži rada apjukumu visu līmeņu izstrādātājiem. Closure izpratne ir ļoti svarīga, lai rakstītu efektīvu, uzturējamu un drošu kodu. Šī visaptverošā rokasgrāmata demistificēs closure ar praktiskiem piemēriem un parādīs to reālās pasaules pielietojumus.

Kas ir Closure?

Vienkāršiem vārdiem sakot, closure ir funkcijas un leksiskās vides kombinācija, kurā šī funkcija tika deklarēta. Tas nozīmē, ka closure ļauj funkcijai piekļūt mainīgajiem no tās apkārtējās darbības jomas pat pēc tam, kad ārējā funkcija ir beigusi darboties. Domājiet par to kā par iekšējo funkciju, kas "atceras" savu vidi.

Lai patiesi to saprastu, sadalīsim galvenās sastāvdaļas:

Maģija notiek tāpēc, ka iekšējā funkcija saglabā piekļuvi mainīgajiem savā leksiskajā darbības jomā pat pēc tam, kad ārējā funkcija ir atgriezusies. Šī uzvedība ir būtiska daļa no tā, kā JavaScript apstrādā darbības jomu un atmiņas pārvaldību.

Kāpēc Closure ir Svarīgi?

Closure nav tikai teorētisks jēdziens; tie ir būtiski daudziem izplatītiem programmēšanas modeļiem JavaScript. Tie nodrošina šādus ieguvumus:

Praktiski JavaScript Closure Piemēri

Iedziļināsimies dažos praktiskos piemēros, lai ilustrētu, kā closure darbojas un kā tos var izmantot reālās pasaules scenārijos.

1. piemērs: Vienkāršs skaitītājs

Šis piemērs parāda, kā closure var izmantot, lai izveidotu skaitītāju, kas saglabā savu stāvokli starp funkciju izsaukumiem.


function createCounter() {
  let count = 0;

  return function() {
    count++;
    console.log(count);
  };
}

const increment = createCounter();

increment(); // Output: 1
increment(); // Output: 2
increment(); // Output: 3

Paskaidrojums:

2. piemērs: Datu iekapsulēšana ar privātiem mainīgajiem

Closure var izmantot, lai izveidotu privātus mainīgos, aizsargājot datus no tiešas piekļuves un modifikācijas no funkcijas ārpuses.


function createBankAccount(initialBalance) {
  let balance = initialBalance;

  return {
    deposit: function(amount) {
      balance += amount;
      return balance; //Returning for demonstration, could be void
    },
    withdraw: function(amount) {
      if (amount <= balance) {
        balance -= amount;
        return balance; //Returning for demonstration, could be void
      } else {
        return "Insufficient funds.";
      }
    },
    getBalance: function() {
      return balance;
    }
  };
}

const account = createBankAccount(1000);

console.log(account.deposit(500)); // Output: 1500
console.log(account.withdraw(200)); // Output: 1300
console.log(account.getBalance()); // Output: 1300

// Trying to access balance directly will not work
// console.log(account.balance); // Output: undefined

Paskaidrojums:

3. piemērs: Closure lietošana ar `setTimeout` ciklā

Closure ir būtiski, strādājot ar asinhronām operācijām, piemēram, setTimeout, īpaši ciklos. Bez closure var rasties neparedzēta uzvedība JavaScript asinhronās būtības dēļ.


for (var i = 1; i <= 5; i++) {
  (function(j) {
    setTimeout(function() {
      console.log("Value of i: " + j);
    }, j * 1000);
  })(i);
}

// Output:
// Value of i: 1 (after 1 second)
// Value of i: 2 (after 2 seconds)
// Value of i: 3 (after 3 seconds)
// Value of i: 4 (after 4 seconds)
// Value of i: 5 (after 5 seconds)

Paskaidrojums:

Izmantojot let tā vietā, lai var ciklā, arī atrisinātu šo problēmu, jo let izveido bloka darbības jomu katrai iterācijai.


for (let i = 1; i <= 5; i++) {
  setTimeout(function() {
    console.log("Value of i: " + i);
  }, i * 1000);
}

// Output (same as above):
// Value of i: 1 (after 1 second)
// Value of i: 2 (after 2 seconds)
// Value of i: 3 (after 3 seconds)
// Value of i: 4 (after 4 seconds)
// Value of i: 5 (after 5 seconds)

4. piemērs: Currying un daļēja pielietošana

Closure ir fundamentāli currying un daļējai pielietošanai, paņēmieniem, ko izmanto, lai pārveidotu funkcijas ar vairākiem argumentiem funkciju virknēs, kuras katra pieņem vienu argumentu.


function multiply(a) {
  return function(b) {
    return function(c) {
      return a * b * c;
    };
  };
}

const multiplyBy5 = multiply(5);
const multiplyBy5And2 = multiplyBy5(2);

console.log(multiplyBy5And2(3)); // Output: 30 (5 * 2 * 3)

Paskaidrojums:

5. piemērs: Moduļa modelis

Closure tiek plaši izmantoti moduļa modelī, kas palīdz organizēt un strukturēt JavaScript kodu, veicinot modularitāti un novēršot nosaukumu konfliktus.


const myModule = (function() {
  let privateVariable = "Hello, world!";

  function privateMethod() {
    console.log(privateVariable);
  }

  return {
    publicMethod: function() {
      privateMethod();
    },
    publicProperty: "This is a public property."
  };
})();

console.log(myModule.publicProperty); // Output: This is a public property.
myModule.publicMethod(); // Output: Hello, world!

// Trying to access privateVariable or privateMethod directly will not work
// console.log(myModule.privateVariable); // Output: undefined
// myModule.privateMethod(); // Output: TypeError: myModule.privateMethod is not a function

Paskaidrojums:

Closure un atmiņas pārvaldība

Lai gan closure ir jaudīgi, ir svarīgi apzināties to potenciālo ietekmi uz atmiņas pārvaldību. Tā kā closure saglabā piekļuvi mainīgajiem no to apkārtējās darbības jomas, tie var neļaut šiem mainīgajiem tikt savāktiem kā atkritumiem, ja tie vairs nav vajadzīgi. Tas var izraisīt atmiņas noplūdes, ja to neapstrādā uzmanīgi.

Lai izvairītos no atmiņas noplūdēm, pārliecinieties, vai esat pārtraucis visas nevajadzīgās atsauces uz mainīgajiem closure iekšienē, kad tie vairs nav vajadzīgi. To var izdarīt, iestatot mainīgos uz null vai pārstrukturējot kodu, lai izvairītos no nevajadzīgu closure izveides.

Biežākās closure kļūdas, no kurām jāizvairās

Secinājums

JavaScript closure ir jaudīgs un būtisks jēdziens, kas jāizprot ikvienam JavaScript izstrādātājam. Tie nodrošina datu iekapsulēšanu, stāvokļa saglabāšanu, augstākas kārtas funkcijas un asinhrono programmēšanu. Izprotot, kā closure darbojas un kā tos efektīvi izmantot, jūs varat rakstīt efektīvāku, uzturējamāku un drošāku kodu.

Šī rokasgrāmata ir sniegusi visaptverošu pārskatu par closure ar praktiskiem piemēriem. Praktizējot un eksperimentējot ar šiem piemēriem, jūs varat padziļināt savu izpratni par closure un kļūt par prasmīgāku JavaScript izstrādātāju.

Papildu mācības