Aggregation —JS: Arrays

One reason loops are used with arrays is aggregation. Aggregation is any calculation that is, as a rule, based on the entire data set, such as finding the maximum, average, sum, etc. of all the data. The aggregation process does not require knowledge of new syntax, but it affects the problem-solving algorithm. Therefore, it makes sense to consider it separately. Let's start by looking for the maximum.

``````const calculateMax = (coll) => {
// If the collection is empty, it cannot have a max value
// In such situations, it usually returns null
// This is a classic example of the guard expression idiom
if (coll.length === 0) {
return null;
}

let max = coll[0]; // Take the first element as the maximum
// Start the traversal with the second element
for (let i = 1; i < coll.length; i += 1) {
const currentElement = coll[i];
// If the current element is larger than the maximum one,
// it becomes the maximum
if (currentElement > max) {
max = currentElement;
}
}

// Don't forget to return the maximum number
return max;
};

console.log(calculateMax([])); // => null
console.log(calculateMax([3, 2, -10, 38, 0])); // => 38
``````

https://repl.it/@hexlet/js-arrays-aggregation-max

Why is this an example of aggregation? Here we see a calculation that involves comparing all the elements to find the one that will be the result of this operation.

Note that the initial value of `max` is the first element, not, say, the number `0`. After all, it may turn out that all numbers in the array are less than `0`, and then we will get the wrong answer.

Now consider searching for the sum:

``````const calculateSum = (coll) => {
// Initial value of the sum
let sum = 0;
for (let i = 0; i < coll.length; i += 1) {
// Add all elements one by one
sum += coll[i];
}

return sum;
};

// The sum of elements always returns a number
// If the array is empty, the sum of its elements is 0
console.log(calculateSum([])); // => 0

console.log(calculateSum([3, 2, -10, 38, 0])); // => 33
// Calculation process
let sum = 0;
sum = sum + 3; // 3
sum = sum + 2; // 5
sum = sum + -10; // -5
sum = sum + 38; // 33
sum = sum + 0; // 33
``````

https://repl.it/@hexlet/js-arrays-aggregation-sum

The algorithm for finding the sum is much simpler, but has a couple of important nuances.

What is the sum of the elements of the empty array? As far as mathematics is concerned, such a sum equals `0`. Seems like common sense. If we have no apples, then we have `0` apples (the number of apples is zero). Functions in programming work according to this logic.

The second point has to do with the initial element of the sum. The variable `sum` has an initial value of 0. Why set a value at all? Any repetitive operation starts with a value. You can't just declare a variable and start working with it inside a loop. This will lead to an incorrect result:

``````  // the initial value is not set
// js automatically makes it equal to undefined
let sum;

// the first iteration of the loop
sum = sum + 2; // ?
``````

The result of this call will be `NaN`, i.e., a not-a-number, inside `sum`. It comes from trying to add `2` and `undefined`. So a value is needed after all. Why is 0 selected in the code above? It is very straightforward to check that all other options will lead to the wrong result. If the initial value is 1, then the result is 1 higher than it should be.

In mathematics, there is a concept of a neutral or identity element of an operation (each operation has its own element). This concept has a very simple meaning. An operation with this element does not change the value on which the operation is performed. In addition, any number plus zero gives the number itself. The same applies for subtraction. Even concatenation has a neutral element, which is an empty string: `'' + 'one'` will be `'one'`.

Aggregation does not always mean that a collection of elements is reduced to a simple value. The result of aggregation can be any complex structure, such as an array. Such examples are often found in real life. The simplest example is a list of unique words in a text.

Are there any more questions? Ask them in the Discussion section.

The Hexlet support team or other students will answer you.

130
courses
1000
exercises
2000+
hours of theory
3200
tests

• 130 courses, 2000+ hours of theory
• 1000 practical tasks in a browser
• 360 000 students
By sending this form, you agree to our Personal Policy and Service Conditions

Suggested learning programs

From a novice to a developer. Get a job or your money back!

Profession
beginner
Development of front-end components for web applications
start anytime 10 months

Use Hexlet to the fullest extent!

• Test your knowledge in quizzes

By sending this form, you agree to our Personal Policy and Service Conditions

Ask questions if you want to discuss a theory or an exercise. Hexlet Support Team and experienced community members can help find answers and solve a problem.