Technology and General Blog

Javascript provides a lot of created-in array capabilities for having responsibilities completed immediately and in an efficient way. Javascript cut down() perform is a person of those people well-liked capabilities utilised to iterate above an array’s things and get the desired consequence.

In this write-up, we will grasp the strategy of the javascript cut down() perform. What is a cut down() operate, and how can we use it to aid in simplifying the Javascript code and complete the tasks successfully and most immediately.

What is the lower() functionality?

Javascript’s minimize() function for the array is applied to reduce the array into a one output benefit.

The lower() functionality usually takes the component of an array a single-by-a person, performs an operation, and returns a one output value. Let’s explore and dig additional into it to comprehend the syntax and its features, alongside with a pair of examples.


array.lower(function_title, initialValue)

The intriguing component of the array’s minimize() functionality is that it can consider a callback function with four arguments. The syntax of the callback purpose and the sequence of arguments will go like this:

function operate_identify(accumulator, worth, index, array)

In the contact back operate of decreasing () approach:

  • The initially parameter is an accumulator that retailers the result just after every single iteration.
  • The 2nd parameter/argument includes the value of the existing array ingredient through the iteration.
  • The third parameter is the optional parameter which is the present index of the array factor in the course of the iteration.
  • Lastly, we can also go the array by itself to the callback operate for getting some personalized functionalities within the callback functionality.

We can also move the original worth to the function. The first price will be the starting up worth of the accumulator.

Let’s try out a couple of examples to see its implementations

Be aware: We will use the browser console to exhibit examples carried out in this article. To open up the browser console:

  • Use the F12 crucial in Chrome and other chromium-based mostly browsers.
  • Use CTRL + Shift + K keyboard shortcut keys for Mozilla.
  • Use Solution + ⌘ + C keyboard shortcut keys in Safari (if developer menu does not look, then open up Tastes by pressing ⌘ +, and in Innovative tab check out “Show Produce menu in menu bar”).

How to use cut down() functionality in JavaScript

The very best case in point to recognize the lower() perform is the addition of quantities saved in the array things.

Instance 1:

Suppose we have an array of figures and we want to add all of these numbers:

var quantities = [23,76,38,55,10]

The initial way to add these figures is to use a for loop:

var sum =

for (leti = i<numbers.length i++)
  sum = sum + numbers[i]


Although we have got the Sum as output, why not use a smart and easy way to perform the same calculation using the reduce() method of the array, where we do not have to mutate the variables like “sum.”

Using of reduce() function:

The reduce() function to calculate the sum will go like this:

var sum = numbers.reduce(addNumbers, 0)

function addNumbers(total, num)

return total + num


In the above code, you can see that we have first passed the addNumbers function to the reduce() function, and in the addNumbers function definition, we just added each number to the accumulator variable total and returned its value.

Once the reduce() function adds all the numbers in the numbers array, it will store the final result in the sum variable.

Lastly, we have just consoled the sum variable to verify whether our reduce() function worked fine or not.

By looking in the screenshot provided above, you can verify that the reduce() function has added all the numbers and shown the result in the console, which is 202 and perfectly calculated.

Another shorter and easier way to write reduce() function is to make the callback function an arrow function:

The syntax of writing the callback function within the reduce() function’s parentheses will be like this:

var sum = numbers.reduce((total, num) =>

return total + num

, )


Alright, this was the basic example in which we have an array of quantities only what about the array of objects. Let’s check out that one particular as well.

Instance 2:

Suppose we have a record of pupils in an array, and we want to estimate the whole costs of all the students:

var students = [
        id: 1,
        name: “John,”
        age: 12,
        fee: 8500
        id: 2,
        name: “Bob”,
        age: 14,
        fee: 9000
        id: 3,
        name: “Steve”,
        age: 10,
        fee: 8000

The minimize() function to estimate the full fees will go like this:

var totalFees = pupils.minimize((whole, college student) =>

return whole + student.fee

, )


Now, the only big difference in this code is that a single item is passed as a price to the callback operate, and within the definition of the callback function, we have accessed the charge and extra it into the accumulator variable.

By searching at the screenshot connected previously mentioned, you can see that students’ service fees are added and exhibited as an output. So this is how we can accessibility the objects of an array in the minimize() function.


In this article, we have learned what a lower() functionality is and how we can use it to assistance in simplifying the Javascript code and finishing the responsibilities successfully and speedily.

We have discovered that the reduce() function lessens the array into a single output price. The cut down() functionality takes a callback operate used to every factor of the array and returns a solitary output value.

This write-up is all about JavaScript’s cut down() perform and its utilization. It is made up of some essential examples that assistance in comprehending the reduce() operate.

Leave a Reply

Your email address will not be published. Required fields are marked *