Yeah, I really want this. It would remove the need for a lot of silly for-loops in my code.

This won't be useful in the core, it can always be included in a plugin.

Reopen if you find places where it can reduce code size in the code, and please point them out.

Thanks

#8379 is a duplicate of this ticket.

Not that I want to revive a dead horse, but given that ''Array.reduce'' found its way into ECMA 1.8 I guess it wouldn't be too bold a move to include it also in Jquery with the same syntax:

https://developer.mozilla.org/en/New_in_JavaScript_1.8

https://bugzilla.mozilla.org/show_bug.cgi?id=363040

I just came here in search of this. It would be nice to have.

Hi. This would be nice to have. Thanks!

reduce is available in native, ES5 compliant JavaScript implementations as well as many open-source utility libraries, see also: http://lodash.com/docs#reduce

reduce is not available in IE8: http://kangax.github.com/es5-compat-table/#.

IE8 represents significant marketshare (~26%) and is probably exclusive in many Windows domain intranets. Why not include it?

There are plenty of libraries that specialize in utility functions, I recommend Lodash http://lodash.com/

Why are $.each and $.map in the core? Plugins/shims can be used for those, too. The point is that they are useful and it's nice to be able to rely on a common set of features everywhere that jQuery is available.

Sometimes adding plugins into a project isn't our call, or requires buy-in from a senior dev.

I'm mostly curious how $.each and $.map are ok, while $.reduce is completely orthogonal to jQuery's core values.

Why are $.each and $.map in the core?

Because we need and use them internally.

Suprised jQuery doesn't have this, I think it is now widely used as a standard language extension and as such it should have this basic function!

#11700 is a duplicate of this ticket.

Even Java is going to add .reduce() now to the JDK 8 Collections API:

http://cr.openjdk.java.net/~briangoetz/lambda/sotc3.html

I'd really love to see this in the jQuery core

Just Do It :)

Yeah, I hate to add the "me too", but this both jives for parity with other array-like methods, and in addition to use wth arrays, would be great for custom ways to serialize nodes, if present also on elements.

var hrefs = $('a').reduce('Your links: ', function (prev, curr) {
    return prev + '<br>' + $(curr).attr('href');
});

This can be done as a plugin. If you have created one, please post a link to it here.

We wouldn't land this in jQuery unless we needed it internally.

So are we to interpret all $.xxx functions as internal only to be used by jQuery itself? Honestly. The line of argument for keeping this out doesn't work. map/reduce goes together.

@anonymous If the method is documented, it's not for internal use only. The functionality is prescribed by the needs of the core library. The argument for keeping this out is perfectly valid. If the method isn't useful inside jQuery, there is absolutely no reason to add it. jQuery is a DOM library, if reducing arrays doesn't help jQuery do it's job, then it doesn't belong.

I think we should have the "reduce" functionality included. This also bridges the gap between the old browsers and new browsers which have "reduce" function in built.I know there are libraries out there like underscore.js which has this functionality, but to use "underscore.js" just to have "reduce" functionality is a crazy idea :) After all we have all these awesome libraries to do better with less code, isn't ?

Given an implementation of "map", there ought to be a "reduce". Maybe it was an error to introduce "map" in the first place, as it creates an expectation that there is also a "reduce". But it is what it is, so add "reduce" and be done with it.

Replying to [comment:23 anonymous]:

Given an implementation of "map", there ought to be a "reduce". Maybe it was an error to introduce "map" in the first place, as it creates an expectation that there is also a "reduce". But it is what it is, so add "reduce" and be done with it.

No.

The argument to not include "reduce" is invalid.

Just an example:

jQuery has "unique" (remove duplicates from an array) and works this way:

1) copies the array

2) sorts it

3) walks the whole array to find duplicates and copies into a new array the results.

Array unique using EC5 code (shorter and faster):

var arrayUnique = function(a) {
  return Array.isArray(a) ? a.reduce(function(p, c) {
    if (p.indexOf(c) < 0) p.push(c);
    return p;
  }, []) : undefined;
};

reduce function can be used to improve lots of parts of the code.

I have created a gist that might be useful for anybody looking for a reduce implementation: https://gist.github.com/lutzissler/6822599

Replying to [comment:25 pedro.ladaria@…]:

jQuery has "unique" (remove duplicates from an array) and works this way: 1) copies the array 2) sorts it 3) walks the whole array to find duplicates and copies into a new array the results. Array unique using EC5 code (shorter and faster):

> var arrayUnique = function(a) {
>   return Array.isArray(a) ? a.reduce(function(p, c) {
>     if (p.indexOf(c) < 0) p.push(c);
>     return p;
>   }, []) : undefined;
> };
> 

This is a bad example. Your function has O(n**2) (quadratic) complexity vs O(n log n) for the algorithm you describe for jQuery. This means that it will scale badly and it's a bad place to use a reduce function.

A alternative to have reduce is reuse it from Array. Something like this:

  (function($){

    $.fn.reduce = function(callback, initial){
      return Array.prototype.reduce.call(this, callback, initial);
    }

  })(jQuery);

As mentioned before, Array.prototype.reduce exists in ECMAScript 5.1

Rather than:

$(...)
  .map(...)
  .reduce(...)

In most modern browsers you can already do:

$(...)
  .map(...)
  .get()
  .reduce(...)

For a compatibility table and pollyfill see MDN

Replying to [comment:28 fabio.montefuscolo@…]:

A alternative to have reduce is reuse it from Array. Something like this:

>   (function($){
> 
>     $.fn.reduce = function(callback, initial){
>       return Array.prototype.reduce.call(this, callback, initial);
>     }
> 
>   })(jQuery);
> 

Or just:

$.fn.reduce = [].reduce;

A little smaller. :P