Relevant usage of js array reduce

This article has compiled a lot of classic code snippets about the js array method reduce, which can help you better understand the use of reduce examples. Let’s learn together.

The following are some relevant code snippets about the javascript array methodreduce that I collected and summarized at work. When encountering other scenarios where this function is used, they will be added one after another. Here is a backup forget. There are so many methods for

javascript arrays. Why do I single out the reduce method? One reason is that I don’t know enough about this method to use it as I like. On the other hand, I also feel the huge charm of this method, which plays a magical role in many scenes.

UnderstandingreduceFunction

reduce() method receives a function as an accumulator (accumulator), and each value in the array starts to decrease (from left to right). Finally a value.

arr.reduce([callback, initialValue])

Look at the following example:

let arr = [1, 2, 3, 4, 5];

// 10代表初始值，p代表每一次的累加值，在第一次为10
// 如果不存在初始值，那么p第一次值为1
// 此时累加的结果为15
let sum = arr.reduce((p, c) => p + c, 10); // 25
// 转成es5的写法即为：
var sum = arr.reduce(function(p, c) {
 console.log(p);
 return p + c;
}, 10);

Fragment 1: Alphabet Game

const anagrams = str => {
 if (str.length <= 2) {
  return str.length === 2 ? [str, str[1] + str[0]] : str;
 }
 return str.split("").reduce((acc, letter, i) => {
  return acc.concat(anagrams(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val));
 }, []);
}

anagrams("abc"); // 结果会是什么呢？

reduceResponsible The first letter of each execution is filtered out, and recursion is responsible for the arrangement and combination of the remaining letters.

Fragment Two: Accumulator

const sum = arr => arr.reduce((acc, val) => acc + val, 0);
sum([1, 2, 3]);

Fragment Three: Counter

const countOccurrences = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);
countOccurrences([1, 2, 3, 2, 2, 5, 1], 1);

Loop through the array. Every time a value is equal to the given value, 1 is added, and the result after addition is used as the initial value for the next time.

Fragment 4: Function Currying

The purpose of function currying is to store data and then execute it in the last step.

const curry = (fn, arity = fn.length, ...args) => 
 arity <= args.length ? fn(...args) : curry.bind(null, fn, arity, ...args);
curry(Math.pow)(2)(10);
curry(Math.min, 3)(10)(50)(2);

Get the length of the current function by judging the parameters of the function (of course you can also specify it yourself). If the parameters passed are less than the current parameters, continue to recurse and store the previous time. parameters passed.

Fragment Five: Array Flattening

const deepFlatten = arr => 
 arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), []);
deepFlatten([1, [2, [3, 4, [5, 6]]]]);

Fragment Six: Generating Fibo Reci Array

const fibonacci = n => Array(n).fill(0).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []);
fibonacci(5);

Fragment 7: Pipe Processor

const pipe = (...funcs) => arg => funcs.reduce((acc, func) => func(acc), arg);
pipe(btoa, x => x.toUpperCase())("Test");

Performs function processing on the passed parameters, and then uses the processed data as The parameters of the next function are passed layer by layer in this way.

Fragment 8: Application of the classic compose function in middleware

<pre class='brush:php;toolbar:false;'>const dispatch = action =&gt; { console.log(&amp;#39;action&amp;#39;, action); return action; } const middleware1 = dispatch =&gt; { return action =&gt; { console.log(&quot;middleware1&quot;); const result = dispatch(action); console.log(&quot;after middleware1&quot;); return result; } } const middleware2 = dispatch =&gt; { return action =&gt; { console.log(&quot;middleware2&quot;); const result = dispatch(action); console.log(&quot;after middleware2&quot;); return result; } } const middleware3 = dispatch =&gt; { return action =&gt; { console.log(&quot;middleware3&quot;); const result = dispatch(action); console.log(&quot;after middleware3&quot;); return result; } } const compose = middlewares =&gt; middlewares.reduce((a, b) =&gt; args =&gt; a(b(args))) const middlewares = [middleware1, middleware2, middleware3]; const afterDispatch = compose(middlewares)(dispatch); const testAction = arg =&gt; { return { type: &quot;TEST_ACTION&quot;, params: arg }; }; afterDispatch(testAction(&quot;1111&quot;));</pre>redux In this way, through multiple layers of middleware, function execution is triggered when the action is actually initiated.

Fragment 9: Redux-actions processing of state Fragment

// redux-actions/src/handleAction.js
const handleAction = (type, reducer, defaultState) => {
 const types = type.toString();
 const [nextReducer, throwReducer] = [reducer, reducer];
 return (state = defaultState, action) => {
  const { type: actionType } = action;
  if (!actionType || types.indexOf(actionType.toString()) === -1) {
   return state;
  }
  return (action.error === true ? throwReducer : nextReducer)(state, action);
 }
}
// reduce-reducers/src/index.js
const reduceReducer = (...reducers) => {
 return (previous, current) => {
  reducers.reduce((p, r) => r(p, current), previous);
 }
}
// redux-actions/src/handleActions.js
const handleActions = (handlers, defaultState, { namespace } = {}) => {
 // reducers的扁平化
 const flattenedReducerMap = flattenReducerMap(handles, namespace);
 // 每一种ACTION下对应的reducer处理方式
 const reducers = Reflect.ownkeys(flattenedReducerMap).map(type => handleAction(
  type,
  flattenedReducerMap[type],
  defaultState
 ));
 // 状态的加工器，用于对reducer的执行
 const reducer = reduceReducers(...reducers);
 // reducer触发
 return (state = defaultState, action) => reducer(state, action);
}

Fragment 10: Data processor

const reducers = {
 totalInEuros: (state, item) => {
  return state.euros += item.price * 0.897424392;
 },
 totalInYen: (state, item) => {
  return state.yens += item.price * 113.852;
 }
};
const manageReducers = reducers => {
 return (state, item) => {
  return Object.keys(reducers).reduce((nextState, key) => {
   reducers[key](state, item);
   return state;
  }, {})
 }
}
const bigTotalPriceReducer = manageReducers(reducers);
const initialState = { euros: 0, yens: 0 };
const items = [{ price: 10 }, { price: 120 }, { price: 1000 }];
const totals = items.reduce(bigTotalPriceReducer, initialState);

Fragment 11: Object null value judgment

let school = {
 name: 'Hope middle school',
 created: '2001',
 classes: [
  {
   name: '三年二班',
   teachers: [
    { name: '张二蛋', age: 26, sex: '男', actor: '班主任' },
    { name: '王小妞', age: 23, sex: '女', actor: '英语老师' }
   ]
  },
  {
   name: '明星班',
   teachers: [
    { name: '欧阳娜娜', age: 29, sex: '女', actor: '班主任' },
    { name: '李易峰', age: 28, sex: '男', actor: '体育老师' },
    { name: '杨幂', age: 111, sex: '女', actor: '艺术老师' }
   ]
  }
 ]
};
// 常规做法
school.classes &&
school.classes[0] &&
school.classes[0].teachers &&
school.classes[0].teachers[0] &&
school.classes[0].teachers[0].name
// reduce方法
const get = (p, o) => p.reduce((xs, x) => (xs && xs[x] ? xs[x] : null), o);
get(['classes', 0, 'teachers', 0, 'name'], school); // 张二蛋

Fragment 12: Grouping

const groupBy = (arr, func) =>
arr.map(typeof func === 'function' ? func : val => val[func]).reduce((acc, val, i) => {
 acc[val] = (acc[val] || []).concat(arr[i]);
 return acc;
}, {});
groupBy([6.1, 4.2, 6.3], Math.floor); 
groupBy(['one', 'two', 'three'], 'length');

First calculate all the key values ​​​​through map, and then classify them according to the created values

Fragment ten Three: Object filtering

const pick = (obj, arr) =>
arr.reduce((acc, curr) => (curr in obj && (acc[curr] = obj[curr]), acc), {});

Traverse according to the given key value, compare whether there is a value with the same key value in the object, and then assign the assigned object to The next initial value

Fragment 14: Delete the value at the specified position in the array

const remove = (arr, func) =>
 Array.isArray(arr)
 ? arr.filter(func).reduce((acc, val) => {
   arr.splice(arr.indexOf(val), 1);
   return acc.concat(val);
 }, []) : [];
const arr = [1, 2, 3, 4];
remove(arr, n => n % 2 == 0);

First based on filter The function filters out the qualified values ​​in the array, and then uses reduce to delete the qualified values ​​in the original array. It can be concluded that the final value of arr becomes [1, 3]

Fragment 15: promises are executed in order

const runPromisesInSeries = ps => ps.reduce((p, next) => p.then(next), Promise.resolve());
const delay = d => new Promise(r => setTimeout(r, d));
const print = args => new Promise(r => r(args));
runPromisesInSeries([() => delay(1000), () => delay(2000), () => print('hello')]);

Fragment 16: Sorting

const orderBy = (arr, props, orders) =>
 [...arr].sort((a, b) =>
  props.reduce((acc, prop, i) => {
   if (acc === 0) {
    const [p1, p2] = orders && orders[i] === 'desc' ? [b[prop], a[prop]] : [a[prop], b[prop]];
    acc = p1 > p2 ? 1 : p1 < p2 ? -1 : 0;
   }
   return acc;
  }, 0)
 );
const users = [{ name: &#39;fred&#39;, age: 48 }, { name: &#39;barney&#39;, age: 36 }, { name: &#39;fly&#39;, age: 26 }];
orderBy(users, [&#39;name&#39;, &#39;age&#39;], [&#39;asc&#39;, &#39;desc&#39;]); 
orderBy(users, [&#39;name&#39;, &#39;age&#39;]);

Fragment Seventeen: Selection

const select = (from, selector) =>
 selector.split('.').reduce((prev, cur) => prev && prev[cur], from);
const obj = { selector: { to: { val: 'val to select' } } };
select(obj, 'selector.to.val');

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.

Related articles:

Detailed interpretation of how Vue configures the packaging tool

How to implement watch to automatically detect data changes in Vue

How to load the permission management module (detailed tutorial)

How to implement communication in vue2.0?

What are the methods of Angular 2 style binding

The above is the detailed content of Relevant usage of js array reduce. For more information, please follow other related articles on the PHP Chinese website!