JavaScript හි අනවශ්‍ය ලූප පසුක්‍රමණයන් ප්‍රශස්ත කිරීම

පහත කේතයේ යම් ක්‍රමලේඛකයෙකු අරාවේ අංකය 3 පවතින්නේදැයි පරීක්ෂා කරයි:

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let exists = false;

for (let elem of arr) {
	if (elem === 3) {
		exists = true;
	}
}

console.log(exists);

ඔහුගේ විසඳුම සමඟ ගැටළුව කුමක්ද? පළමුවෙන්ම පෙනෙන්නේ ලූපය තුළ කිසිදු අනවශ්‍ය මෙහෙයුමක් සිදු නොවන බවයි. කෙසේ වෙතත්, ගැටළුව වන්නේ අරාව තුළ අංකය 3 ඇති බව තීරණය වූ පසු, ලූපය තවදුරටත් අරාවේ අවසානය දක්වා කරකැවෙමින් පවතින බවයි.

වඩාත් අභිමත වන්නේ, අංකය 3 අරාවේ ආරම්භයට සමීපයෙන්ම හමු වන අතර, අරාවේ දිග, උදාහරණයක් ලෙස, 1000 මූලද්‍රව්‍ය වන විටය. එවිට අනවශ්‍ය ලූප පුනරාවර්තන දහසක් සිදු වේ! එය ප්‍රශස්ත නොවේ.

ලූපය නියමිත වේලාවට නතර කිරීමෙන් කේතය ප්‍රශස්ත කරමු:

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let exists = false;

for (let elem of arr) {
	if (elem === 3) {
		exists = true;
		break;
	}
}

console.log(exists);

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

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let sum = 0;
let i = 1;

for (let elem of arr) {
	sum += elem;
	
	if (sum <= 10) {
		i++;
	}
}

console.log(i);

පහත කේතය නියමිත පරාසයෙන් ඉරට්ටේ සංඛ්‍යා මුද්‍රණය කරයි. ප්‍රශස්තකරණය සිදු කරන්න:

for (let i = 0; i <= 100; i++) {
	if (i % 2 === 0) {
		console.log(i);
	}
}

පහත කේතය එකවරම 2 සහ 3 න් බෙදිය හැකි සංඛ්‍යා මුද්‍රණය කරයි. ප්‍රශස්තකරණය සිදු කරන්න:

for (let i = 0; i <= 100; i++) {
	if (i % 2 === 0 && i % 3 === 0) {
		console.log(i);
	}
}

පහත කේතය වත්මන් වසරේ ඇති සියලුම සිකුරාදා 13 වැනි දින සොයයි. ප්‍රශස්තකරණය සිදු කරන්න:

for (let i = 0; i <= 11; i++) {
	let curr = new Date;
	let last = new Date(curr.getFullYear(), i + 1, 0).getDate();
	
	for (let j = 1; j <= last; j++) {
		let date = new Date(curr.getFullYear(), i, j);
		
		if (date.getDate() === 13 && date.getDay() === 5) {
			console.log(date);
		}
	}
}