DEV Community

Discussion on: Array manipulation in JavaScript 🧐

 
puritanic profile image
Darkø Tasevski • Edited

I find using map/reduce/filter much more easier to read than this mumbo jumbo:

if(!Number.isInteger(num)) continue
  acc = typeof acc === "undefined" ? num * 2 : acc + num * 2
}

This wouldn't pass any code review in my office... We're writing code for the machine but humans will need to read that code too, and as far as I know, performance gains are minimal, and in the end, you have @babel plugin which transforms map/reduce/find and similar methods into for loops.

Would like to add that you should use those "advanced" array methods only if you know what you're doing, in the end, it's really important for the developer to know what's going under the hood and to know, at least, to write some of those examples in regular for/while loops.

Thread Thread
 
qm3ster profile image
Mihail Malo

I know exactly what they're doing, not just from practice but I've read the spec. One of the few ES specs I actually fully read.

These are just simplified versions of what is going on, what happens if we inline a crude implementation of the current spec vs what would be happening if it was done with transducers/iterator adapters, where all operations are applied to each item in order.
Also, the formatting in your quote is a bit strange.
It should look like this:

if(!Number.isInteger(num)) continue
acc = typeof acc === "undefined" ? num * 2 : acc + num * 2

But yeah, if it isn't clear by now, I didn't advocate that anyone actually write either of the two unrolled codes in a project, they were just desugared explanations.

Thread Thread
 
rokkoo profile image
Alfonso

Truly reasons, I'm a junior developer and I'm used to using these methods because they are easy to use and their implementation too.
In countable occasions, I need to work in low-level loops to search optimization of code.
Thanx for sharing your knowledge it has been helpful and this babel package.

Thread Thread
 
qm3ster profile image
Mihail Malo • Edited

Writing it by hand it would probably look something like this:

let sumOfDoubles = 0
for (let i = 0; i < numbers.length; i++) {
  const num = numbers[i]
  if(Number.isInteger(num))
    sumOfDoubles += num * 2
}

But if you are writing application code with a framework, and not making your own library, you will probably have better returns if you look at your algorithms and data structures. It's very rare to be limited by loop performance in a frontend application.
If your collection is like 10 items, and your filtering and mapping predicates are complicated, there's usually no shame in applying a filter and then a map separately.

Thread Thread
 
mdor profile image
Marco Antonio Dominguez • Edited

I agree depends on the case, some of the issues are related to maintainability other to performance issues, most of the cases is because some people is trying to overcomplicate things because some imaginary scalability issues.

Despite the fact the code is more performant, we should consider:
1 - Number of items
2 - Amount of operations
3 - Think in the different benefits coming from different worlds, FP, OOP, etc.

I saw more issues coming from extremely premature optimizations than performance issues, even with large datasets...

In addition, the code can be even readable

// example 1
const total = numbers.reduce((t, c) => t + (!Number.isInteger(c) ? 0 : (c*2)), 0);

// Example 2
let acc = 0;
for (let i = 0, size = numbers.length; i < size; i++) {
  const cur = numbers[i]
  acc += (!Number.isInteger(cur) ? 0 : (cur * 2));
}

// Example 3
const total = numbers
  .filter(cur => !!cur && Number.isInteger(cur))
  .reduce((t,c) => (t + c* 2), 0)
  // We clean up the falsy values (including 0), and we avoided another iteration

Again, it depends on the conditions,