JavaScript හි චක්‍රීය මෙහෙයුම් ප්‍රශස්තකරණය

සැහැල්ලු මෙහෙයුමක් පවා, චක්‍රයක තුළ නැවත නැවතත් සිදු කළහොත්, විශාල සම්පත් ප්‍රමාණයක් අහිමි කළ හැකිය.

අපි උදාහරණයක් දෙස බලමු. අපට යම් අරාවක් ලබා දී ඇතැයි සිතමු:

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

අපි මෙම අරාවේ මූලද්‍රව්‍යවල සාමාන්‍යය සොයා ගනිමු. මේ සඳහා, මූලද්‍රව්‍යවල එකතුව සොයා එය ප්‍රමාණයෙන් බෙදිය යුතුය. යම් ක්‍රමලේඛකයෙක් මෙම ගැටළුව දැනටමත් පහත ආකාරයට විසඳා ඇතැයි සිතමු:

javascriptlet avg  = 0;

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

console.log(avg);

අපි එවැනි විසඳුමක ගැටලු දෙස බලමු. තාක්ෂණිකව කේතය නිවැරදිව ක්‍රියා කරන අතර නිවැරදි පිළිතුර ලබා දෙයි. කාරණය නම්, ගණිතමය වශයෙන් නිවැරදි ය සම්පූර්ණ එකතුව ප්‍රමාණයෙන් බෙදීම සහ සෑම වාරයක්ම වෙන වෙනම ප්‍රමාණයෙන් බෙදීම.

කෙසේ වෙතත්, තවත් ගැටළුවක් පැන නගී. කාරණය නම්, අපි බෙදීම සිදු කරන්නෙමු අපගේ අරාවේ ඇති මූලද්‍රව්‍ය ගණනට සමාන වාර ගණනක්. එහි ප්‍රතිඵලයක් ලෙස, අපි අනවශ්‍ය මෙහෙයුම් විශාල ප්‍රමාණයක් සිදු කරමු, මන්ද බෙදීම සිදු කළ හැකි විය අවසානයේ - එක් වරක්, සම්පූර්ණ සොයාගත් එකතුව බෙදීමෙන්.

අපි අපගේ කේතය ප්‍රශස්තකරණය කරමු:

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);