Optimering van sikliese operasies in JavaScript

Selfs 'n ligte operasie, wat herhaaldelik in 'n lus uitgevoer word, kan baie hulpbronne verbruik.

Kom ons kyk na 'n voorbeeld. Gestel ons het die volgende array:

javascriptlet arr = [1, 2, 3, 4, 5, 6];

Kom ons vind die gemiddelde van die elemente van hierdie array. Om dit te doen, moet ons die som van die elemente vind en dit deur die hoeveelheid deel. Gestel 'n programmeerder het reeds hierdie probleem opgelos op die volgende manier:

javascriptlet avg  = 0;

for (let elem of arr) {
  avg += elem / arr.length;
}

console.log(avg);

Kom ons kyk na die probleme met hierdie oplossing. Tegnies werk die kode korrek en gee die regte antwoord. Die feit is dat dit wiskundig korrek is om óf die hele som deur die hoeveelheid te deel, óf om elke term afsonderlik deur die hoeveelheid te deel.

Daar ontstaan egter 'n ander probleem. Die saak is dat ons die deling sal uitvoer soveel keer as wat daar elemente in ons array is. En dit blyk dat ons 'n groot aantal onnodige operasies doen, aangesien ons die deling kon doen aan die einde - een keer, deur die hele gevinde som te deel.

Kom ons optimaliseer ons kode:

javascriptlet sum = 0;

for (let elem of arr) {
  sum += elem;
}

let avg = sum / arr.length;
console.log(avg);

javascriptfor (let i = 1900; i <= 2100; i++) {
  let curr = new Date;
  let date = new Date(i, curr.getMonth(), curr.getDate());
  
  if (curr.getDay() === date.getDay()) {
    console.log(date);
  }
}

javascriptlet obj = {a: 10, b: 20, c: 30, d: 40, e: 50};
let sum = 0;
  
for (let key in obj) {
  if (String(obj[key])[0] === '1' || String(obj[key])[0] === '2') {
    sum += obj[key];
  }
}

console.log(sum);