[yankjenets]

Optimize for readability above everything else. Almost all of these examples I'd argue would be better suited for something like .map(). Little point in being overly cute, and if you are working with arrays large enough such that doing multiple passes is that much of a performance hit client-side, you have other issues going on.

[azangru]

> Almost all of these examples I'd argue would be better suited for something like .map()

Roughly half of his examples take an array and return either a differently-sized array, or a different data structure altogether. I can’t imagine how one could argue for a map in these cases.

[hn_throwaway_99]

Use the right tool for the job. Array to potentially different sized array? Use flatMap (which he implements in his example, albeit not it an optimal way). Array to single object or value? Use reduce.

[noir_lord]

Indeed, reduce is the swiss army knife since you can use it (sometimes when you shouldn't) to implement most of the other methods of map/filter etc.

[_bxg1]

I think the intent was simply to teach. Obviously if something can be done with map() instead of reduce(), it'll be more readable as map(). But seeing how the other list functions can be made out of reduce() helps you understand how it works.

[jrimbault]

That's also my minor nitpick, I feel like the syntax : `list.filter(myFilter).map(transform)` is clear about what I do and, each functions has a clear goal.

Otherwise I enjoyed reading this.

[mikeryan]

While your example reads a bit better, you’re now iterating through your list twice.

[fwip]

Most code isn't performance-critical.

This pattern will probably be dominated by the time taken to filter and map, not loop iteration.

[saagarjha]

Does JavaScript have adapters to covert lists into generators or lazy iterators?

[hn_throwaway_99]

Unfortunately not in a way that can optimize these methods. This is one reason the Java Streams API, which has a similar purpose (e.g. map, filter, flatMap, reduce, etc.), is a better design IMO because you can chain together method calls without creating (and iterating) the full array at each step.

[londt8]

Technically there is no iteration in filter/map/reduce at all.

[Stratoscope]

That's incorrect. All of those functions are implemented using iteration.

Consider this excerpt from the .map() polyfill on MDN:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

    // 7. Let k be 0
    k = 0;

    // 8. Repeat, while k < len
    while (k < len) {
      // [loop body omitted]

      // d. Increase k by 1.
      k++;
    }