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

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

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

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

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

let avg  = 0;

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

console.log(avg);

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

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

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

let sum = 0;

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

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

පහත කේතය ප්‍රශස්තකරණය කරන්න:

for (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);
	}
}

පහත කේතය ප්‍රශස්තකරණය කරන්න:

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