Latest edu news

edu

Five Interesting Ways to Use Array.reduce() (And One Boring Way)

By feedproxy.google.com
Published On :: Wed, 18 Dec 2019 12:00:00 +0000

Chris Ferdinandi turns the heat down low and lets the sauce reduce while we take a look at how to add spice to our source with a sprinkling of Array.reduce(). Just a little ingenuity with the humblest of functions.

Of all the modern array methods, the one I had the hardest time wrapping my head around was Array.reduce().

On the surface, it seems like a simple, boring method that doesn’t do much. But below its humble exterior, Array.reduce() is actually a powerful, flexible addition to your developer toolkit.

Today, we’re going to look at some cool things you can do with Array.reduce().

How `Array.reduce()` works

Most of the modern array methods return a new array. The Array.reduce() method is a bit more flexible. It can return anything. Its purpose is to take an array and condense its content into a single value.

That value can be a number, a string, or even an object or new array. That’s the part that’s always tripped me up – I didn’t realize just how flexible it is!

The syntax

The Array.reduce() accepts two arguments: a callback method to run against each item in the array, and a starting value.

The callback also accepts two arguments: the accumulator, which is the current combined value, and the current item in the loop. Whatever you return is used as the accumulator for the next item in the loop. On the very first loop, that starting value is used instead.

var myNewArray = [].reduce(function (accumulator, current) {
  return accumulator;
}, starting);

Let’s look at some examples to make this all tangible.

1. Adding numbers together

Let’s say you had an array of numbers that you wanted to add together. Using Array.forEach(), you might do something like this:

var total = 0;

[1, 2, 3].forEach(function (num) {
  total += num;
});

This is the cliche example for using Array.reduce(). I find the word accumulator confusing, so in this example, I’m calling it sum, because that’s what it is.

var total = [1, 2, 3].reduce(function (sum, current) {
  return sum + current;
}, 0);

Here, we pass in 0 as our starting value.

In the callback, we add the current value to the sum, which has our starting value of 0 on the first loop, then 1 (the starting value of 0 plus the item value of 1), then 3 (the sum value of 1 plus the item value of 2), and so on.

Here’s a demo.

2. Combining multiple array methods into `Array.map()` and `Array.filter()` into a single step

Imagine you had an array of wizards at Hogwarts.

var wizards = [
  {
    name: 'Harry Potter',
    house: 'Gryfindor'
  },
  {
    name: 'Cedric Diggory',
    house: 'Hufflepuff'
  },
  {
    name: 'Tonks',
    house: 'Hufflepuff'
  },
  {
    name: 'Ronald Weasley',
    house: 'Gryfindor'
  },
  {
    name: 'Hermione Granger',
    house: 'Gryfindor'
  }
];

You want to create a new array that contains just the names of wizards who are in Hufflepuff. One way you could do that is by using the Array.filter() method to get back just wizards whose house property is Hufflepuff. Then, you’d use the Array.map() method to create a new array containing just the name property for the remaining wizards.

// Get the names of the wizards in Hufflepuff
var hufflepuff = wizards.filter(function (wizard) {
  return wizard.house === 'Hufflepuff';
}).map(function (wizard) {
  return wizard.name;
});

With the Array.reduce() method, we can get the same array in a single pass, improving our performance. You pass in an empty array ([]) as the starting value. On each pass, you check to see if the wizard.house is Hufflepuff. If it is, you push it to the newArr (our accumulator in this example). If not, you do nothing.

Either way, you return the newArr to become the accumulator on the next pass.

// Get the names of the wizards in Hufflepuff
var hufflepuff = wizards.reduce(function (newArr, wizard) {
  if (wizard.house === 'Hufflepuff') {
    newArr.push(wizard.name);
  }
  return newArr;
}, []);

Here’s another demo.

3. Creating markup from an array

What if, instead of creating an array of names, we wanted to create an unordered list of wizards in Hufflepuff? Instead of passing an empty array into Array.reduce() as our starting value, we’ll pass in an empty string ('') and call it html.

If the wizard.house equals Hufflepuff, we’ll concatenate our html string with the wizard.name wrapped in an opening and closing list item (li). Then, we’ll return the html to become the accumulator on the next loop.

// Create a list of wizards in Hufflepuff
var hufflepuffList = wizards.reduce(function (html, wizard) {
  if (wizard.house === 'Hufflepuff') {
    html += '<li>' + wizard.name + '</li>';
  }
  return html;
}, '');

Add an opening and closing unordered list element before and after Array.reduce(), and you’re ready to inject your markup string into the DOM.

// Create a list of wizards in Hufflepuff
var hufflepuffList = '<ul>' + wizards.reduce(function (html, wizard) {
  if (wizard.house === 'Hufflepuff') {
    html += '<li>' + wizard.name + '</li>';
  }
  return html;
}, '') + '</ul>';

See it in action here.

4. Grouping similar items in an array together

The lodash library has a groupBy() method takes a collection of items as an array and groups them together into an object based on some criteria.

Let’s say you want an array of numbers.

If you wanted to group all of the items in numbers together based on their integer value, you would do this with lodash.

var numbers = [6.1, 4.2, 6.3];

// returns {'4': [4.2], '6': [6.1, 6.3]}
_.groupBy(numbers, Math.floor);

If you had an array of words, and you wanted to group the items in words by their length, you would do this.

var words = ['one', 'two', 'three'];

// returns {'3': ['one', 'two'], '5': ['three']}
_.groupBy(words, 'length');

Creating a `groupBy()` function with `Array.reduce()`

You can recreate that same functionality using the Array.reduce() method.

We’ll create a helper function, groupBy(), that accepts the array and criteria to sort by as arguments. Inside groupBy(), we’ll run Array.reduce() on our array, passing in an empty object ({}) as our starting point, and return the result.

var groupBy = function (arr, criteria) {
  return arr.reduce(function (obj, item) {
    // Some code will go here...
  }, {});
};

Inside the Array.reduce() callback function, we’ll check to see if the criteria is a function, or a property of the item. Then we’ll get its value from the current item.

If there’s no property in the obj with that value yet, we’ll create it and assign an empty array as its value. Finally, we’ll push the item to that key, and return the object as the accumulator for the next loop.

var groupBy = function (arr, criteria) {
  return arr.reduce(function (obj, item) {

    // Check if the criteria is a function to run on the item or a property of it
    var key = typeof criteria === 'function' ? criteria(item) : item[criteria];

    // If the key doesn't exist yet, create it
    if (!obj.hasOwnProperty(key)) {
      obj[key] = [];
    }

    // Push the value to the object
    obj[key].push(item);

    // Return the object to the next item in the loop
    return obj;

  }, {});
};

Here’s a demo of the completed helper function.

Special thanks to Tom Bremer for helping me make some improvements to this one. You can find this helper function and more like it on the Vanilla JS Toolkit.

5. Combining data from two sources into an array

Remember our array of wizards?

var wizards = [
  {
    name: 'Harry Potter',
    house: 'Gryfindor'
  },
  {
    name: 'Cedric Diggory',
    house: 'Hufflepuff'
  },
  {
    name: 'Tonks',
    house: 'Hufflepuff'
  },
  {
    name: 'Ronald Weasley',
    house: 'Gryfindor'
  },
  {
    name: 'Hermione Granger',
    house: 'Gryfindor'
  }
];

What if you had another data set, an object of house points each wizard has earned.

var points = {
  HarryPotter: 500,
  CedricDiggory: 750,
  RonaldWeasley: 100,
  HermioneGranger: 1270
};

Imagine you wanted to combine both sets of data into a single array, with the number of points added to each wizard’s data in the wizards array. How would you do it?

The Array.reduce() method is perfect for this!

var wizardsWithPoints = wizards.reduce(function (arr, wizard) {

  // Get the key for the points object by removing spaces from the wizard's name
  var key = wizard.name.replace(' ', '');

  // If the wizard has points, add them
  // Otherwise, set them to 0
  if (points[key]) {
    wizard.points = points[key];
  } else {
    wizard.points = 0;
  }

  // Push the wizard object to the new array
  arr.push(wizard);

  // Return the array
  return arr;

}, []);

Here’s a demo combining data from two sources into an array.

6. Combining data from two sources into an object

What if you instead wanted to combine the two data sources into an object, where each wizard’s name was the key, and their house and points were properties? Again, the Array.reduce() method is perfect for this.

var wizardsAsAnObject = wizards.reduce(function (obj, wizard) {

  // Get the key for the points object by removing spaces from the wizard's name
  var key = wizard.name.replace(' ', '');

  // If the wizard has points, add them
  // Otherwise, set them to 0
  if (points[key]) {
    wizard.points = points[key];
  } else {
    wizard.points = 0;
  }

  // Remove the name property
  delete wizard.name;

  // Add wizard data to the new object
  obj[key] = wizard;

  // Return the array
  return obj;

}, {});

Here’s a demo combining two data sets into an object.

Should you use `Array.reduce()` more?

The Array.reduce() method has gone from being something I thought was pointless to my favorite JavaScript method. So, should you use it? And when?

The Array.reduce() method has fantastic browser support. It works in all modern browsers, and IE9 and above. It’s been supported in mobile browsers for a long time, too. If you need to go back even further than that, you can add a polyfill to push support back to IE6.

The biggest complaint you can make about Array.reduce() is that it’s confusing for people who have never encountered it before. Combining Array.filter() with Array.map() is slower to run and involves extra steps, but it’s easier to read. It’s obvious from the names of the methods what they’re supposed to be doing.

That said, there are times where Array.reduce() makes things that would be complicated more simple rather than more complicated. The groupBy() helper function is a good example.

Ultimately, this is another tool to add to your toolkit. A tool that, if used right, can give you super powers.

About the author

Chris Ferdinandi helps people learn vanilla JavaScript. He believes there’s a simpler, more resilient way to make things for the web.

Chris is the author of the Vanilla JS Pocket Guide series, creator of the Vanilla JS Academy training program, and host of the Vanilla JS Podcast. His developer tips newsletter is read by thousands of developers each weekday.

He’s taught developers at organizations like Chobani and the Boston Globe, and his JavaScript plugins have been used used by Apple and Harvard Business School. Chris Coyier, the founder of CSS-Tricks and CodePen, has described his writing as “infinitely quote-worthy.”

Chris loves pirates, puppies, and Pixar movies, and lives near horse farms in rural Massachusetts. He runs Go Make Things with Bailey Puppy, a lab-mix from Tennessee.

Poll power: the Voter Education Project and the movement for the ballot in the American South / Evan Faulkenbury

By library.mit.edu
Published On :: Sun, 26 Apr 2020 09:04:30 EDT

Dewey Library - JK2160.F38 2019

Five Interesting Ways to Use Array.reduce() (And One Boring Way)

How Array.reduce() works

The syntax

1. Adding numbers together

2. Combining multiple array methods into Array.map() and Array.filter() into a single step

3. Creating markup from an array

4. Grouping similar items in an array together

Creating a groupBy() function with Array.reduce()

5. Combining data from two sources into an array

6. Combining data from two sources into an object

Should you use Array.reduce() more?

About the author

Poll power: the Voter Education Project and the movement for the ballot in the American South / Evan Faulkenbury

Tamil Nadu: Jayalalithaa slams centre for reducing allocation

Singur Redux: Co pulls out of Haldia

Mamata’s Bengal to introduce bill for reservation in higher education

Trying to make procedures transparent, simpler: Mamata tells industrialists

10 positive cases with Koyambedu links emerge in Chittoor district

136 JSJ TrackingJS with Eduardo Lundgren

178 JSJ Tech Education and The Business of Running Front End Masters with Marc Grabanski

179 JSJ redux and React with Dan Abramov

MJS 126: Eduardo San Martin Morote

Sponsors

Links

Picks

Youth and higher education in Africa [electronic resource] : the cases of Cameroon, South Africa, Eritrea, and Zimbabwe / edited by Donald P. Chimanikire

Youth development and critical education [electronic resource] : the promise of democratic action / Richard D. Lakes

[ASAP] Reduction of Optical Gain Threshold in CsPbI<sub>3</sub> Nanocrystals Achieved by Generation of Asymmetric Hot-Biexcitons

Ecological processes at marine fronts : oases in the ocean / Eduardo Marcelo Acha, Alberto Piola, Oscar Iribarne, Hermes Mianzan

Conservation education and outreach techniques / Susan K. Jacobson, Mallory D. McDuff, and Martha C. Monroe

Marine pollution and climate change / editors, Andrés Hugo Arias and Jorge Eduardo Marcovecchio

Practical evaluation for conservation education and outreach : assessing impacts & enhancing effectiveness / Katherine Clavijo and Kathayoon A. Khalil ; foreword by Judy Diamond

Association Between Genetically Proxied Inhibition of HMG-CoA Reductase and Epithelial Ovarian Cancer

[ASAP] Kinetics of the <italic toggle="yes">Trans</italic> Effect in Ruthenium Complexes Provide Insight into the Factors That Control Activity and Stability in CO<sub>2</sub> Electroreduction

[ASAP] Net-Clipping: An Approach to Deduce the Topology of Metal–Organic Frameworks Built with Zigzag Ligands

[ASAP] Speciation of Cu Surfaces During the Electrochemical CO Reduction Reaction

[ASAP] Co-immobilization of a Rh Catalyst and a Keggin Polyoxometalate in the UiO-67 Zr-Based Metal–Organic Framework: In Depth Structural Characterization and Photocatalytic Properties for CO<sub>2</sub> Reduction

Green synthetic processes and procedures / edited by Roberto Ballini

Flow chemistry: integrated approaches for practical applications / edited by Santiago V. Luis, Eduardo Garcia-Verdugo

Richard Hooker, beyond certainty / Andrea Russell (the Queen's Foundation for Ecumenical Theological Education, Birmingham, UK)

Polypyrrole modified magnetic reduced graphene oxide composites: synthesis, characterization and application for selective lead adsorption

Europium oxide nanorod-reduced graphene oxide nanocomposites towards supercapacitors

Electrochemical reduction of CO2 to ethylene on Cu/CuxO-GO composites in aqueous solution

Nitrogen-doped RuS2 nanoparticles containing in situ reduced Ru as an efficient electrocatalyst for hydrogen evolution

Redux modules and code-splitting

Redux modules

Redux reducer registry

Working with mindfulness [electronic resource] : mindfulness, work, and stress reduction / a conversation with Mirabai Bush and George Kohlrieser

Making Education [electronic resource] : Material School Design and Educational Governance

JAMA Pediatrics : Exposure to High-Performing Schools and Reduced Adolescent Substance Use

JAMA Otolaryngology–Head & Neck Surgery : Readmission Determinants and Benefit of Experienced Surgeons in Otolaryngology Procedures

JAMA Internal Medicine : Association of the Work Schedules of Hospitalists With Patient Outcomes of Hospitalization

Indian-American Renu Khator to head US council on education

Efficient CO2 electroreduction to CO at low overpotentials using a surface-reconstructed and N-coordinated Zn electrocatalyst

Photo-reduction enables catalyst regeneration in Fenton reaction on an Fe2O3-decorated TiO2 nanotube-based photocatalyst

Dehydrogenation of amines in aryl-amine functionalized pincer-like nitrogen-donor redox non-innocent ligands via ligand reduction on a Ni(II) template

Military professionalism and humanitarian law: the struggle to reduce the hazards of war / Yishai Beer

Language rights and the law in the European Union / Eduardo D. Faingold

The education of Brett Kavanaugh: an investigation / Robin Pogrebin and Kate Kelly

The UN Security Council and international criminal tribunals: procedure matters / Christodoulos Kaoutzanis

North Korean graphic novels : seduction of the innocent? / Martin Petersen

Understanding educator beliefs in teaching and assessing soft skills : an examination within the Malaysian public higher education sector / Wan Sofiah Meor Osman

Law, practice and procedure of arbitration / Datuk Professor Sundra Rajoo

The seduction of the simple : insights on Singapore's future directions / Devadas Krishnadas

Students want more climate change education. Their teachers and professors are starting to listen

Structure of active ribonucleotide reductase solved with cryo-electron microscopy

A look at the potential impact of shutting down the Department of Education

MRI-Guided Radiation Therapy Reduces Long-Term Side Effects for Patients with Prostate Cancer

Google’s new AI-powered ‘Learn About’ tool makes educational research interactive and engaging

Grundfos is on a mission to reduce energy used by pumps worldwide

The need for continuing education

Education, certification work together

Trade-show education

Avoid OSHA citations by making sure everyone follows safety procedures on the jobsite

Reducing oil and gas workers exposure to vapors

Online education continues to boom

Michael D. McCann, MD, MBA, Celebrated for Excellence in Health Care and Education

Undergraduate Teacher Education Info Session (November 14, 2024 7:00pm)

Dinner for Democracy: Education Policy (November 14, 2024 5:30pm)

Waste Reduction Goal Town Hall (November 14, 2024 4:00pm)

How `Array.reduce()` works

2. Combining multiple array methods into `Array.map()` and `Array.filter()` into a single step

Creating a `groupBy()` function with `Array.reduce()`

Should you use `Array.reduce()` more?