Optimalisatie van cyclische operaties in JavaScript

Zelfs een lichte operatie, herhaaldelijk uitgevoerd in een lus, kan veel middelen kosten.

Laten we een voorbeeld bekijken. Stel we hebben een bepaalde array:

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

Laten we het gemiddelde van de elementen van deze array vinden. Om dit te doen moeten we de som van de elementen vinden en deze delen door de hoeveelheid. Stel dat een programmeur deze taak al als volgt heeft opgelost:

let avg  = 0;

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

console.log(avg);

Laten we de problemen van zo'n oplossing bekijken. Technisch gezien werkt de code correct en geeft het het juiste antwoord. Het zit zo dat het wiskundig gezien correct is om zowel de hele som door de hoeveelheid te delen, als elk van de termen afzonderlijk door de hoeveelheid te delen.

Er ontstaat echter een ander probleem. Het zit zo dat we de deling zullen uitvoeren zoveel keer als er elementen in onze array zitten. En het blijkt dat we een groot aantal overbodige operaties uitvoeren, terwijl de deling aan het einde had kunnen gebeuren - één keer, door de hele gevonden som te delen.

Laten we onze code optimaliseren:

let sum = 0;

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

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

Optimaliseer de volgende code:

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

Optimaliseer de volgende code:

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