Is there a native Javascript method that returns the sum of the elements of an Array ? How does array_sum() do in PHP

Question

I would like to add the elements of an Array. As the example below:

array_soma = [5, 4, 3, 2, 1];
let resultado = metodo_somador(array_soma);

//Gostaria que nesse console retornasse o valor de 15
console.log(resultado);

• There in the example, the methodo_adder() would be a method native of JS (I couldn’t find and I don’t know if it exists).
• However, would not like to create a function, with loops, just to do this.
• In the PHP there is the array_sum() that is native and returns this sum of the elements of an Array.

Thank you for your attention. Thank you!

Answer 1

When something is that simple I really don’t see any reason to exist native and probably the developers of Ecmascript (aka Javascript) probably "agree", not that they haven’t created functions for trivial things in other cases, but it probably depends on odd factors and decisions that are beyond our understanding, the staff of the https://php.net is a community, they like to fill functions, even for trivial things, because that’s how that community thinks (remembering that not all were good devs in the early versions of PHP, a lot of talk on the internet and jokes confirm the problems).

Not exists in Javascript nothing native to tell, you can use Array.reduce, but understanding the basics helps a lot, a simple for you would achieve a similar result and with for still has better performance to perform multiple operations, something like:

var array_soma = [5, 4, 3, 2, 1];
var resultado = 0;

for (var i = array_soma.length - 1; i >= 0; i--) {
    resultado += array_soma[i];
}

console.log(resultado);

You don’t have to expect there to be a function for every trivial thing you need, if it is simple then use the simple, if you will even use this function in a number of different places and want to facilitate, then do something like:

function array_sum(arr) {
    let resultado = 0;

    for (var i = arr.length - 1; i >= 0; i--) {
        resultado += arr[i];
    }

    return resultado;
}

In use would be:

var array_soma = [5, 4, 3, 2, 1];
var resultado = array_sum(array_soma);

console.log(resultado);


function array_sum(arr) {
    let resultado = 0;

    for (var i = arr.length - 1; i >= 0; i--) {
        resultado += arr[i];
    }

    return resultado;
}

---

Benchmark (performance test)

I performed a local performance test, via Nodejs, which does not have so much interference from other processes, see the result:

Array.reduce x 135,434,338 ops/sec 0.37% (94 runs sampled)

Simple for x 146,437,628 ops/sec 0.60% (94 runs sampled)

For into Function x 145,747,268 ops/sec 0.34% (93 runs sampled)

Fastest is Simple for

Even the inside of a function managed 10,000,000 operations per second more than the Array.reduce.

The "online" test is not so reliable, but anyway you can try and see the difference in https://jsbench.me/8rk60td9hs/ (online test), Chrome result:

Answer 2

Another version for Guilherme to put in the benchmarks :D

  var i = arr.length;  // use let se o ambiente for moderno
  var sum = 0;        
  while (i--) sum += arr[i];

Following demonstration:

var array_soma = [5, 4, 3, 2, 1];
var resultado = array_sum(array_soma);

console.log(resultado);


function array_sum(arr) {
  var i = arr.length;  // use let se o ambiente for moderno
  var sum = 0;        
  while (i--) sum += arr[i];
  return sum;
}

Answer 3

You can use the reduce and add the current element to the "previous sum".

array_soma = [5, 4, 3, 2, 1];
let resultado = array_soma.reduce((acumulador, valorAtual) => acumulador + valorAtual, 0);

console.log(resultado);

However, this method may even be slower than using a "simple for". There is this simple performance test to compare both.

Documentation of reduce: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce

This method is not specifically for "adding up". Perhaps it would be easier for you to write your own sum if it has to be used in more places (although it is actually a "simple for"). The method reduce exists in several languages and the goal of it is actually to "reduce" an array to an object.