JavaScriptin efektityypit: Sivuvaikutusten seuranta ja hallinta

JavaScript, webin kaikkialla läsnä oleva kieli, antaa kehittäjille mahdollisuuden luoda dynaamisia ja interaktiivisia käyttäjäkokemuksia monenlaisilla laitteilla ja alustoilla. Sen luontainen joustavuus tuo kuitenkin mukanaan haasteita, erityisesti sivuvaikutusten osalta. Tämä kattava opas tutkii JavaScriptin efektityyppejä keskittyen sivuvaikutusten seurannan ja hallinnan keskeisiin näkökohtiin. Se antaa sinulle tiedot ja työkalut vankkojen, ylläpidettävien ja skaalautuvien sovellusten rakentamiseen sijainnistasi tai tiimisi kokoonpanosta riippumatta.

JavaScriptin efektityyppien ymmärtäminen

JavaScript-koodi voidaan jakaa karkeasti sen käyttäytymisen perusteella: puhtaaseen ja epäpuhtaaseen. Puhtaat funktiot tuottavat saman tuloksen samoilla syötteillä, eikä niillä ole sivuvaikutuksia. Epäpuhtaat funktiot sen sijaan ovat vuorovaikutuksessa ulkomaailman kanssa ja voivat aiheuttaa sivuvaikutuksia.

Puhtaat funktiot

Puhtaat funktiot ovat funktionaalisen ohjelmoinnin kulmakivi, jotka edistävät ennustettavuutta ja helpottavat virheenjäljitystä. Ne noudattavat kahta keskeistä periaatetta:

• Deterministisyys: Samoilla syötteillä ne palauttavat aina saman tuloksen.
• Ei sivuvaikutuksia: Ne eivät muokkaa mitään oman toimialueensa ulkopuolella. Ne eivät ole vuorovaikutuksessa DOM:n kanssa, tee API-kutsuja tai muokkaa globaaleja muuttujia.

Esimerkki:

            
function add(a, b) {
  return a + b;
}

            

              
                Copy
              
            
          

Tässä esimerkissä `add` on puhdas funktio. Riippumatta siitä, milloin tai missä se suoritetaan, `add(2, 3)` -kutsu palauttaa aina arvon `5` eikä muuta mitään ulkoista tilaa.

Epäpuhtaat funktiot ja sivuvaikutukset

Epäpuhtaat funktiot puolestaan ovat vuorovaikutuksessa ulkomaailman kanssa, mikä johtaa sivuvaikutuksiin. Näitä vaikutuksia voivat olla:

• Globaalien muuttujien muokkaaminen: Funktion toimialueen ulkopuolella määriteltyjen muuttujien muuttaminen.
• API-kutsujen tekeminen: Datan hakeminen ulkoisilta palvelimilta (esim. `fetch`- tai `XMLHttpRequest`-metodilla).
• DOM:n manipulointi: HTML-dokumentin rakenteen tai sisällön muuttaminen.
• Paikalliseen tallennustilaan tai evästeisiin kirjoittaminen: Datan tallentaminen pysyvästi käyttäjän selaimeen.
• `console.log`:n tai `alert`:n käyttäminen: Vuorovaikutus käyttöliittymän tai virheenjäljitystyökalujen kanssa.
• Ajastimien käyttö (esim. `setTimeout` tai `setInterval`): Asynkronisten operaatioiden ajoittaminen.
• Satunnaislukujen generointi (varauksin): Vaikka satunnaislukujen generointi itsessään saattaa vaikuttaa 'puhtaalta' (koska funktion allekirjoitus ei muutu, ja 'tulos' voidaan nähdä myös 'syötteenä'), jos satunnaislukugeneraattorin *siementä* ei hallita (tai sitä ei ole lainkaan), käyttäytymisestä tulee epäpuhdasta.

Esimerkki:

            
let globalCounter = 0;

function incrementCounter() {
  globalCounter++; // Sivuvaikutus: globaalin muuttujan muokkaaminen
  return globalCounter;
}

            

              
                Copy
              
            
          

Tässä tapauksessa `incrementCounter` on epäpuhdas. Se muokkaa `globalCounter`-muuttujaa, mikä on sivuvaikutus. Sen tulos riippuu `globalCounter`-muuttujan tilasta ennen funktion kutsumista, mikä tekee siitä ei-deterministisen, jos muuttujan aiempaa arvoa ei tunneta.

Miksi sivuvaikutuksia pitäisi hallita?

Sivuvaikutusten tehokas hallinta on ratkaisevan tärkeää useista syistä:

• Ennustettavuus: Sivuvaikutusten vähentäminen tekee koodista helpommin ymmärrettävää, pääteltävää ja virheenjäljitettävää. Voit luottaa siihen, että funktio toimii odotetusti.
• Testattavuus: Puhtaat funktiot ovat paljon helpompia testata, koska niiden käyttäytyminen on ennustettavaa. Voit eristää ne ja varmistaa niiden tuloksen pelkästään niiden syötteiden perusteella. Epäpuhtaiden funktioiden testaaminen vaatii ulkoisten riippuvuuksien mockaamista ja vuorovaikutuksen hallintaa ympäristön kanssa (esim. API-vastausten mockaaminen).
• Ylläpidettävyys: Sivuvaikutusten minimointi yksinkertaistaa koodin refaktorointia ja ylläpitoa. Muutokset yhdessä koodin osassa eivät todennäköisesti aiheuta odottamattomia ongelmia muualla.
• Skaalautuvuus: Hyvin hallitut sivuvaikutukset edistävät skaalautuvampaa arkkitehtuuria, jolloin tiimit voivat työskennellä eri sovelluksen osien parissa itsenäisesti ilman konflikteja tai virheiden aiheuttamista. Tämä on erityisen tärkeää globaalisti hajautetuille tiimeille.
• Samanaikaisuus ja rinnakkaisuus: Sivuvaikutusten vähentäminen tasoittaa tietä turvallisemmalle samanaikaiselle ja rinnakkaiselle suoritukselle, mikä johtaa parempaan suorituskykyyn ja reagoivuuteen.
• Tehokas virheenjäljitys: Kun sivuvaikutuksia hallitaan, virheiden alkuperän jäljittäminen helpottuu. Voit nopeasti tunnistaa, missä tilan muutokset tapahtuivat.

Tekniikoita sivuvaikutusten seurantaan ja hallintaan

Useat tekniikat voivat auttaa sinua seuraamaan ja hallitsemaan sivuvaikutuksia tehokkaasti. Lähestymistavan valinta riippuu usein sovelluksen monimutkaisuudesta ja tiimin mieltymyksistä.

1. Funktionaalisen ohjelmoinnin periaatteet

Funktionaalisen ohjelmoinnin periaatteiden omaksuminen on keskeinen strategia sivuvaikutusten minimoimiseksi:

• Muuttumattomuus (Immutability): Vältä olemassa olevien tietorakenteiden muokkaamista. Luo sen sijaan uusia, joissa on halutut muutokset. Kirjastot, kuten Immer JavaScriptissä, voivat auttaa muuttumattomissa päivityksissä.
• Puhtaat funktiot: Suunnittele funktiot mahdollisimman puhtaiksi. Erota puhtaat funktiot epäpuhtaista.
• Deklaratiivinen ohjelmointi: Keskity siihen, *mitä* on tehtävä, sen sijaan että keskittyisit siihen, *miten* se tehdään. Tämä edistää luettavuutta ja vähentää sivuvaikutusten todennäköisyyttä. Kehykset ja kirjastot helpottavat usein tätä tyyliä (esim. React ja sen deklaratiiviset käyttöliittymäpäivitykset).
• Koostaminen (Composition): Jaa monimutkaiset tehtävät pienempiin, hallittaviin funktioihin. Koostaminen antaa sinun yhdistää ja käyttää funktioita uudelleen, mikä helpottaa koodin käyttäytymisen ymmärtämistä.

Esimerkki muuttumattomuudesta (spread-operaattorilla):

            
const originalArray = [1, 2, 3];
const newArray = [...originalArray, 4]; // Luo uuden taulukon [1, 2, 3, 4] muokkaamatta alkuperäistä taulukkoa

            

              
                Copy
              
            
          

2. Sivuvaikutusten eristäminen

Erota selkeästi sivuvaikutuksia sisältävät funktiot puhtaista funktioista. Tämä eristää koodisi ne alueet, jotka ovat vuorovaikutuksessa ulkomaailman kanssa, tehden niistä helpommin hallittavia ja testattavia. Harkitse omien moduulien tai palveluiden luomista tiettyjen sivuvaikutusten käsittelyyn (esim. `apiService` API-kutsuille, `domService` DOM-manipulaatioille).

Esimerkki:

            
// Puhdas funktio
function calculateTotal(items) {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// Epäpuhdas funktio (API-kutsu)
async function fetchProducts() {
  const response = await fetch('/api/products');
  return await response.json();
}

// Puhdas funktio, joka kuluttaa epäpuhtaan funktion tuloksen
async function displayProducts() {
  const products = await fetchProducts();
  // Tuotteiden jatkokäsittely API-kutsun tuloksen perusteella.
}

            

              
                Copy
              
            
          

3. Tarkkailija-suunnittelumalli (Observer Pattern)

Tarkkailija-suunnittelumalli mahdollistaa löyhän kytkennän komponenttien välillä. Sen sijaan, että komponentit laukaisisivat suoraan sivuvaikutuksia (kuten DOM-päivityksiä tai API-kutsuja), ne voivat *tarkkailla* sovelluksen tilan muutoksia ja reagoida niihin. Kirjastot, kuten RxJS, tai omat toteutukset tarkkailija-mallista voivat olla tässä arvokkaita.

Esimerkki (yksinkertaistettu):

            
class Subject {
  constructor() {
    this.observers = [];
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }

  notify(data) {
    this.observers.forEach(observer => observer(data));
  }
}

// Luo Subject
const stateSubject = new Subject();

// Tarkkailija käyttöliittymän päivittämiseen
function updateUI(data) {
  console.log('Käyttöliittymä päivitetty tiedoilla:', data);
  // DOM-manipulaatio käyttöliittymän päivittämiseksi
}

// Tilaa käyttöliittymän tarkkailija subjectiin
stateSubject.subscribe(updateUI);

// Laukaisemalla tilanmuutoksen ja ilmoittamalla tarkkailijoille
stateSubject.notify({ message: 'Data päivitetty!' }); // Käyttöliittymä päivittyy automaattisesti

            

              
                Copy
              
            
          

4. Datavirtakirjastot (Redux, Vuex, Zustand)

Tilanhallintakirjastot, kuten Redux, Vuex ja Zustand, tarjoavat keskitetyn säilön sovelluksen tilalle ja pakottavat usein yksisuuntaisen datavirran. Nämä kirjastot kannustavat muuttumattomuuteen ja ennustettaviin tilanmuutoksiin, mikä yksinkertaistaa sivuvaikutusten hallintaa.

• Redux: Suosittu tilanhallintakirjasto, jota käytetään usein Reactin kanssa. Se edistää ennustettavaa tilakonetta.
• Vuex: Vue.js:n virallinen tilanhallintakirjasto, joka on suunniteltu Vuen komponenttipohjaiseen arkkitehtuuriin.
• Zustand: Kevyt ja mielipiteitä jakamaton tilanhallintakirjasto Reactille, usein yksinkertaisempi vaihtoehto Reduxille pienemmissä projekteissa.

Nämä kirjastot sisältävät tyypillisesti actioneita (jotka edustavat käyttäjän vuorovaikutusta tai tapahtumia), jotka laukaisevat muutoksia tilassa. Väliohjelmistoja (esim. Redux Thunk, Redux Saga) käytetään usein käsittelemään asynkronisia actioneita ja sivuvaikutuksia. Esimerkiksi action saattaa lähettää API-kutsun, ja väliohjelmisto hoitaa asynkronisen operaation päivittäen tilan sen valmistuttua.

5. Väliohjelmistot (Middleware) ja sivuvaikutusten käsittely

Väliohjelmistot tilanhallintakirjastoissa (tai omat väliohjelmistototeutukset) antavat sinun siepata ja muokata actioneiden tai tapahtumien virtaa. Tämä on tehokas mekanismi sivuvaikutusten hallintaan. Voit esimerkiksi luoda väliohjelmiston, joka sieppaa API-kutsuja sisältävät actionit, suorittaa API-kutsun ja lähettää sitten uuden actionin API-vastauksen kanssa. Tämä vastuualueiden erottelu pitää komponenttisi keskittyneenä käyttöliittymälogiikkaan ja tilanhallintaan.

Esimerkki (Redux Thunk):

            
// Action creator (sivuvaikutuksella - API-kutsu)
function fetchData() {
  return async (dispatch) => {
    dispatch({ type: 'FETCH_DATA_REQUEST' }); // Lähetä lataustila
    try {
      const response = await fetch('/api/data');
      const data = await response.json();
      dispatch({ type: 'FETCH_DATA_SUCCESS', payload: data }); // Lähetä onnistumisaction
    } catch (error) {
      dispatch({ type: 'FETCH_DATA_FAILURE', payload: error }); // Lähetä virheaction
    }
  };
}

            

              
                Copy
              
            
          

Tämä esimerkki käyttää Redux Thunk -väliohjelmistoa. `fetchData`-action creator palauttaa funktion, joka voi lähettää muita actioneita. Tämä funktio hoitaa API-kutsun (sivuvaikutus) ja lähettää asianmukaiset actionit Redux-storen päivittämiseksi API:n vastauksen perusteella.

6. Muuttumattomuuskirjastot (Immutability Libraries)

Kirjastot, kuten Immer tai Immutable.js, auttavat sinua hallitsemaan muuttumattomia tietorakenteita. Nämä kirjastot tarjoavat käteviä tapoja päivittää objekteja ja taulukoita muuttamatta alkuperäistä dataa. Tämä auttaa estämään odottamattomia sivuvaikutuksia ja helpottaa muutosten seuraamista.

Esimerkki (Immer):

            
import produce from 'immer';

const initialState = { items: [{ id: 1, name: 'Item 1' }] };

const nextState = produce(initialState, draft => {
  draft.items.push({ id: 2, name: 'Item 2' }); // Turvallinen luonnoksen muokkaus
  draft.items[0].name = 'Updated Item 1';
});

console.log(initialState); // Pysyy muuttumattomana
console.log(nextState); // Uusi tila muutoksilla

            

              
                Copy
              
            
          

7. Lintterit ja koodianalyysityökalut

Työkalut, kuten ESLint asianmukaisilla liitännäisillä, voivat auttaa sinua noudattamaan koodaustyyliohjeita, havaitsemaan mahdollisia sivuvaikutuksia ja tunnistamaan koodia, joka rikkoo sääntöjäsi. Sääntöjen asettaminen liittyen muuttuvuuteen, funktioiden puhtauteen ja tiettyjen funktioiden käyttöön voi parantaa merkittävästi koodin laatua. Harkitse konfiguraation, kuten `eslint-config-standard-with-typescript`, käyttöä järkevien oletusasetusten saamiseksi. Esimerkki ESLint-säännöstä (`no-param-reassign`), joka estää funktion parametrien tahattoman muokkaamisen:

            
// ESLint-konfiguraatio (esim. .eslintrc.js)
module.exports = {
  rules: {
    'no-param-reassign': 'error', // Estää parametrien uudelleenmäärittelyn.
  },
};

            

              
                Copy
              
            
          

Tämä auttaa havaitsemaan yleisiä sivuvaikutusten lähteitä kehityksen aikana.

8. Yksikkötestaus

Kirjoita perusteellisia yksikkötestejä varmistaaksesi funktioiden ja komponenttien käyttäytymisen. Keskity puhtaiden funktioiden testaamiseen varmistaaksesi, että ne tuottavat oikean tuloksen annetulla syötteellä. Epäpuhtaiden funktioiden osalta mockaa ulkoiset riippuvuudet (API-kutsut, DOM-vuorovaikutukset) eristääksesi niiden käyttäytymisen ja varmistaaksesi, että odotetut sivuvaikutukset tapahtuvat.

Työkalut, kuten Jest, Mocha ja Jasmine, yhdistettynä mockauskirjastoihin, ovat korvaamattomia JavaScript-koodin testaamisessa.

9. Koodikatselmukset ja pariohjelmointi

Koodikatselmukset ovat erinomainen tapa havaita mahdollisia sivuvaikutuksia ja varmistaa koodin laatu. Pariohjelmointi parantaa tätä prosessia entisestään, jolloin kaksi kehittäjää voi työskennellä yhdessä analysoidakseen ja parantaakseen koodia reaaliaikaisesti. Tämä yhteistyöhön perustuva lähestymistapa helpottaa tiedon jakamista ja auttaa tunnistamaan potentiaalisia ongelmia varhaisessa vaiheessa.

10. Lokitus ja valvonta

Toteuta vankka lokitus ja valvonta sovelluksesi käyttäytymisen seuraamiseksi tuotannossa. Tämä auttaa sinua tunnistamaan odottamattomia sivuvaikutuksia, suorituskyvyn pullonkauloja ja muita ongelmia. Käytä työkaluja, kuten Sentry, Bugsnag, tai omia lokitusratkaisuja virheiden kaappaamiseen ja käyttäjien vuorovaikutusten seuraamiseen.

Parhaat käytännöt sivuvaikutusten hallintaan JavaScriptissä

Tässä on joitakin parhaita käytäntöjä, joita noudattaa:

• Priorisoi puhtaita funktioita: Suunnittele mahdollisimman monta funktiota puhtaiksi. Tavoittele funktionaalista ohjelmointityyliä aina kun se on mahdollista.
• Erota vastuualueet: Erota selkeästi sivuvaikutuksia sisältävät funktiot puhtaista funktioista. Luo omia moduuleja tai palveluita sivuvaikutusten käsittelyyn.
• Omaksu muuttumattomuus: Käytä muuttumattomia tietorakenteita estääksesi tahattomia muutoksia.
• Käytä tilanhallintakirjastoja: Hyödynnä tilanhallintakirjastoja, kuten Redux, Vuex tai Zustand, sovelluksen tilan hallintaan ja sivuvaikutusten kontrollointiin.
• Hyödynnä väliohjelmistoja: Käytä väliohjelmistoja asynkronisten operaatioiden, API-kutsujen ja muiden sivuvaikutusten hallittuun käsittelyyn.
• Kirjoita kattavia yksikkötestejä: Testaa sekä puhtaita että epäpuhtaita funktioita, mockaten ulkoiset riippuvuudet jälkimmäisille.
• Valvo koodaustyyliä: Käytä lintterityökaluja koodaustyyliohjeiden noudattamiseen ja yleisten virheiden estämiseen.
• Tee säännöllisiä koodikatselmuksia: Anna muiden kehittäjien katselmoida koodisi mahdollisten ongelmien havaitsemiseksi.
• Toteuta vankka lokitus ja valvonta: Seuraa sovelluksen käyttäytymistä tuotannossa tunnistaaksesi ja ratkaistaksesi ongelmat nopeasti.
• Dokumentoi sivuvaikutukset: Dokumentoi selkeästi kaikki sivuvaikutukset, joita funktiolla tai komponentilla on. Tämä tiedottaa muita kehittäjiä ja auttaa tulevassa ylläpidossa.
• Suosi deklaratiivista ohjelmointia: Tavoittele deklaratiivista tyyliä imperatiivisen sijaan kuvaillaksesi, mitä haluat saavuttaa, sen sijaan miten se saavutetaan.
• Pidä funktiot pieninä ja keskittyneinä: Pienet, keskittyneet funktiot ovat helpompia testata, ymmärtää ja ylläpitää, mikä luonnostaan lieventää sivuvaikutusten hallinnan monimutkaisuutta.

Edistyneempiä näkökohtia

1. Asynkroninen JavaScript ja sivuvaikutukset

Asynkroniset operaatiot, kuten API-kutsut, lisäävät monimutkaisuutta sivuvaikutusten hallintaan. `async/await`:n, Promise-lupausten ja takaisinkutsufunktioiden käyttö vaatii huolellista harkintaa. Varmista, että kaikki asynkroniset operaatiot käsitellään hallitusti ja ennustettavasti, usein hyödyntäen tilanhallintakirjastoja tai väliohjelmistoja näiden operaatioiden tilan (lataus, onnistuminen, virhe) hallintaan. Harkitse kirjastojen, kuten RxJS, käyttöä monimutkaisten asynkronisten datavirtojen hallintaan.

2. Palvelinpuolen renderöinti (SSR) ja sivuvaikutukset

Käytettäessä SSR:ää (esim. Next.js:n tai Nuxt.js:n kanssa), ole tietoinen sivuvaikutuksista, jotka saattavat tapahtua palvelinpuolen renderöinnin aikana. Koodi, joka luottaa DOM:iin tai selainkohtaisiin API:hin, todennäköisesti rikkoutuu SSR:n aikana. Varmista, että kaikki DOM-riippuvuuksia sisältävä koodi suoritetaan vain asiakaspuolella (esim. `useEffect`-hookissa Reactissa tai `mounted`-elinkaarihookissa Vuessa). Käsittele lisäksi huolellisesti datan hakua ja muita operaatioita, joilla voi olla sivuvaikutuksia, varmistaaksesi niiden oikean suorituksen sekä palvelimella että asiakkaalla.

3. Web Workerit ja sivuvaikutukset

Web Workerit mahdollistavat JavaScript-koodin suorittamisen erillisessä säikeessä, estäen pääsäikeen tukkeutumisen. Niitä voidaan käyttää laskennallisesti raskaiden tehtävien ulkoistamiseen tai sivuvaikutusten, kuten API-kutsujen, käsittelyyn. Web Workereita käytettäessä on ratkaisevan tärkeää hallita viestintää pääsäikeen ja worker-säikeen välillä huolellisesti. Säikeiden välillä siirrettävä data sarjallistetaan ja deserialisoidaan, mikä voi aiheuttaa lisäkustannuksia. Rakenna koodisi kapseloimaan sivuvaikutukset worker-säikeen sisälle, jotta pääsäie pysyy reagoivana. Muista, että workerilla on oma toimialueensa eikä se voi suoraan käyttää DOM:ia. Viestintä tapahtuu viesteillä ja `postMessage()`- ja `onmessage`-metodeilla.

4. Virheenkäsittely ja sivuvaikutukset

Toteuta vankat virheenkäsittelymekanismit sivuvaikutusten hallitsemiseksi sulavasti. Ota virheet kiinni asynkronisissa operaatioissa (esim. käyttämällä `try...catch`-lohkoja `async/await`:n kanssa tai `.catch()`-lohkoja Promise-lupausten kanssa). Käsittele API-kutsuista palautetut virheet asianmukaisesti ja varmista, että sovelluksesi voi toipua vioista vioittamatta tilaa tai aiheuttamatta odottamattomia sivuvaikutuksia. Virheiden lokitus ja käyttäjäpalaute ovat olennainen osa hyvää virheenkäsittelyjärjestelmää. Harkitse keskitetyn virheenkäsittelymekanismin luomista poikkeusten johdonmukaiseen hallintaan koko sovelluksessa.

5. Kansainvälistäminen (i18n) ja sivuvaikutukset

Kun rakennat sovelluksia globaalille yleisölle, harkitse huolellisesti sivuvaikutusten vaikutusta kansainvälistämiseen (i18n) ja lokalisointiin (l10n). Käytä i18n-kirjastoa (esim. i18next tai js-i18n) käännösten käsittelyyn ja lokalisoidun sisällön tarjoamiseen. Päivämäärien, aikojen ja valuuttojen kanssa työskennellessäsi hyödynnä JavaScriptin `Intl`-objektia varmistaaksesi oikean muotoilun käyttäjän lokaalin mukaan. Varmista, että kaikki sivuvaikutukset, kuten API-kutsut tai DOM-manipulaatiot, ovat yhteensopivia lokalisoidun sisällön ja käyttäjäkokemuksen kanssa.

Yhteenveto

Sivuvaikutusten hallinta on kriittinen osa vankkojen, ylläpidettävien ja skaalautuvien JavaScript-sovellusten rakentamista. Ymmärtämällä erilaisia efektityyppejä, omaksumalla asianmukaisia tekniikoita ja noudattamalla parhaita käytäntöjä voit parantaa merkittävästi koodisi laatua ja luotettavuutta. Rakennatpa sitten yksinkertaista verkkosovellusta tai monimutkaista, globaalisti hajautettua järjestelmää, harkittu lähestymistapa sivuvaikutusten hallintaan on menestyksen kannalta olennaista. Funktionaalisen ohjelmoinnin periaatteiden omaksuminen, sivuvaikutusten eristäminen, tilanhallintakirjastojen hyödyntäminen ja kattavien testien kirjoittaminen ovat avainasemassa tehokkaan ja ylläpidettävän JavaScript-koodin rakentamisessa. Webin kehittyessä kyky hallita tehokkaasti sivuvaikutuksia pysyy ratkaisevan tärkeänä taitona kaikille JavaScript-kehittäjille.